Fix: Suppress -Wshadow warnings in headers on macOS (Fixes #20790)

core/base/inc/TAttMarker.h

@@ -15,35 +15,34 @@
 
 #include "Rtypes.h"
 
-class TColorNumber;
 
 class TAttMarker {
 
 protected:
-   Color_t    fMarkerColor;       ///< Marker color
+   Color_t    fMarkerColor;       ///< Marker color index
    Style_t    fMarkerStyle;       ///< Marker style
    Size_t     fMarkerSize;        ///< Marker size
 
 public:
    TAttMarker();
-   TAttMarker(Color_t color, Style_t style, Size_t msize);
+   TAttMarker(Color_t markerColor, Style_t style, Size_t msize);
    virtual ~TAttMarker();
-           void     Copy(TAttMarker &attmarker) const;
+          void     Copy(TAttMarker &attmarker) const;
    virtual Color_t  GetMarkerColor() const {return fMarkerColor;} ///< Return the marker color
    virtual Style_t  GetMarkerStyle() const {return fMarkerStyle;} ///< Return the marker style
    virtual Size_t   GetMarkerSize()  const {return fMarkerSize;}  ///< Return the marker size
    virtual void     Modify();
-   virtual void     ResetAttMarker(Option_t *toption="");
+   virtual void     ResetAttMarker(Option_t *option="");
    virtual void     SaveMarkerAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t sizdef=1);
    virtual void     SetMarkerAttributes();  // *MENU*
-   virtual void     SetMarkerColor(Color_t mcolor=1) { fMarkerColor = mcolor;} ///< Set the marker color
-   virtual void     SetMarkerColorAlpha(Color_t mcolor, Float_t malpha);
-   virtual void     SetMarkerStyle(Style_t mstyle=1) { fMarkerStyle = mstyle;} ///< Set the marker style
+   virtual void     SetMarkerColor(Color_t tmarkerColor); ///< Set the marker color
+   virtual void     SetMarkerColorAlpha(Color_t tmarkerColor, Float_t malpha);
+   virtual void     SetMarkerStyle(Style_t style); ///< Set the marker style
    /// Set the marker size.
    /// Note that the marker styles number 1 6 and 7 (the dots), cannot be scaled.
    /// They are meant to be very fast to draw and are always drawn with the same number of pixels;
    /// therefore this method does not apply on them.
-   virtual void     SetMarkerSize(Size_t msize=1)    { fMarkerSize  = msize;}
+   virtual void     SetMarkerSize(Size_t msize);
 
    static Style_t GetMarkerStyleBase(Style_t style);
    static Width_t GetMarkerLineWidth(Style_t style);
@@ -69,4 +68,3 @@ class TAttMarker {
                       kFourSquaresPlus=49 };
 
 #endif
-

core/base/inc/TAttText.h

@@ -28,7 +28,7 @@ class TAttText {
 
 public:
    TAttText();
-   TAttText(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize);
+   TAttText(Int_t textAlign, Float_t textAngle, Color_t textColor, Style_t textFont, Float_t tsize);
    virtual ~TAttText();
            void     Copy(TAttText &atttext) const;
    virtual Short_t  GetTextAlign() const {return fTextAlign;} ///< Return the text alignment
@@ -41,7 +41,8 @@ class TAttText {
    virtual void     ResetAttText(Option_t *toption="");
    virtual void     SaveTextAttributes(std::ostream &out, const char *name, Int_t alidef=12, Float_t angdef=0, Int_t coldef=1, Int_t fondef=61, Float_t sizdef=1);
    virtual void     SetTextAttributes();  // *MENU*
-   virtual void     SetTextAlign(Short_t align=11) { fTextAlign = align;}  ///< Set the text alignment
+   virtual void     SetTextAlign(Short_t textAlign = 11) { fTextAlign = textAlign; }  ///< Set the text alignment
+
    virtual void     SetTextAngle(Float_t tangle=0) { fTextAngle = tangle;} ///< Set the text angle
    virtual void     SetTextColor(Color_t tcolor=1) { fTextColor = tcolor;} ///< Set the text color
    virtual void     SetTextColorAlpha(Color_t tcolor, Float_t talpha);
@@ -58,4 +59,3 @@ class TAttText {
                     kVAlignBottom=1, kVAlignCenter=2, kVAlignTop=3};
 
 #endif
-

core/base/inc/TSystem.h

@@ -52,7 +52,19 @@ enum EAccessMode {
    kFileExists        = 0,
    kExecutePermission = 1,
    kWritePermission   = 2,
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
    kReadPermission    = 4
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 };
 
 enum ELogOption {

core/base/src/TAttFill.cxx

@@ -188,10 +188,10 @@ TAttFill::TAttFill()
 ///   - color Fill Color
 ///   - style Fill Style
 
-TAttFill::TAttFill(Color_t color, Style_t style)
+TAttFill::TAttFill(Color_t fillColor, Style_t fillStyle)
 {
-   fFillColor = color;
-   fFillStyle = style;
+   fFillColor = fillColor;
+   fFillStyle = fillStyle;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

core/base/src/TAttLine.cxx

@@ -156,11 +156,11 @@ TAttLine::TAttLine()
 ///            defined using TStyle::SetLineStyleString.
 ///  - width : expressed in pixel units
 
-TAttLine::TAttLine(Color_t color, Style_t style, Width_t width)
+TAttLine::TAttLine(Color_t lineColor, Style_t lineStyle, Width_t lineWidth)
 {
-   fLineColor = color;
-   fLineWidth = width;
-   fLineStyle = style;
+   fLineColor = lineColor;
+   fLineWidth = lineWidth;
+   fLineStyle = lineStyle;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

core/base/src/TAttMarker.cxx

@@ -223,11 +223,11 @@ TAttMarker::TAttMarker()
 ///  - style : Marker style (from 1 to 30)
 ///  - size  : marker size (float)
 
-TAttMarker::TAttMarker(Color_t color, Style_t style, Size_t msize)
+TAttMarker::TAttMarker(Color_t markerColor, Style_t markerStyle, Size_t markerSize)
 {
-   fMarkerColor = color;
-   fMarkerSize  = msize;
-   fMarkerStyle = style;
+   fMarkerColor = markerColor;
+   fMarkerSize  = markerSize;
+   fMarkerStyle = markerStyle;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

core/base/src/TAttText.cxx

@@ -272,12 +272,12 @@ TAttText::TAttText()
 ///
 /// Text attributes are taken from the argument list.
 
-TAttText::TAttText(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize)
+TAttText::TAttText(Int_t textAlign, Float_t textAngle, Color_t textColor, Style_t textFont, Float_t tsize)
 {
-   fTextAlign = align;
-   fTextAngle = angle;
-   fTextColor = color;
-   fTextFont  = font;
+   fTextAlign = textAlign;
+   fTextAngle = textAngle;
+   fTextColor = textColor;
+   fTextFont  = textFont;
    fTextSize  = tsize;
 }
 

core/meta/inc/TClass.h

@@ -591,16 +591,16 @@ friend class TStreamerInfo;
 
    // Function to retrieve the TClass object and dictionary function
    static void           AddClass(TClass *cl);
-   static void           AddClassToDeclIdMap(TDictionary::DeclId_t id, TClass* cl);
+   static void           AddClassToDeclIdMap(TDictionary::DeclId_t declId, TClass* cl);
    static void           RemoveClass(TClass *cl);
-   static void           RemoveClassDeclId(TDictionary::DeclId_t id);
+   static void           RemoveClassDeclId(TDictionary::DeclId_t declId);
    static TClass        *GetClass(const char *name, Bool_t load = kTRUE, Bool_t silent = kFALSE);
    static TClass        *GetClass(const char *name, Bool_t load, Bool_t silent, size_t hint_pair_offset, size_t hint_pair_size);
    static TClass        *GetClass(const std::type_info &typeinfo, Bool_t load = kTRUE, Bool_t silent = kFALSE, size_t hint_pair_offset = 0, size_t hint_pair_size = 0);
    static TClass        *GetClass(ClassInfo_t *info, Bool_t load = kTRUE, Bool_t silent = kFALSE);
    template<typename T>
    static TClass        *GetClass(Bool_t load = kTRUE, Bool_t silent = kFALSE);
-   static Bool_t         GetClass(DeclId_t id, std::vector<TClass*> &classes);
+   static Bool_t         GetClass(DeclId_t declId, std::vector<TClass*> &classes);
    static DictFuncPtr_t  GetDict (const char *cname);
    static DictFuncPtr_t  GetDict (const std::type_info &info);
 
@@ -681,13 +681,13 @@ template <typename T> TClass *GetClass(const T * /* dummy */) { return TClass::G
 
 #ifndef R__NO_CLASS_TEMPLATE_SPECIALIZATION
    // This can only be used when the template overload resolution can distinguish between T* and T**
-   template <typename T> TClass* GetClass(      T**       /* dummy */) { return TClass::GetClass<T>(); }
-   template <typename T> TClass* GetClass(const T**       /* dummy */) { return TClass::GetClass<T>(); }
+   template <typename T> TClass* GetClass(      T** /* dummy */) { return TClass::GetClass<T>(); }
+   template <typename T> TClass* GetClass(const T** /* dummy */) { return TClass::GetClass<T>(); }
    template <typename T> TClass* GetClass(      T* const* /* dummy */) { return TClass::GetClass<T>(); }
    template <typename T> TClass* GetClass(const T* const* /* dummy */) { return TClass::GetClass<T>(); }
 #endif
 
-   extern TClass *CreateClass(const char *cname, Version_t id,
+   extern TClass *CreateClass(const char *cname, Version_t cversion,
                               const char *dfil, const char *ifil,
                               Int_t dl, Int_t il);
 }

io/io/inc/TFile.h

@@ -1,3 +1,10 @@
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
 // @(#)root/io:$Id$
 // Author: Rene Brun   28/11/94
 
@@ -263,7 +270,19 @@ class TFile : public TDirectoryFile {
       // Note that to avoid a circular dependency, this value is used
       // hard coded in TObject.cxx.
       k630forwardCompatibility = BIT(2),
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
       kRecovered     = BIT(10),
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
       kHasReferences = BIT(11),
       kDevNull       = BIT(12),
       kWriteError    = BIT(14),

math/matrix/inc/TMatrixT.h

@@ -56,7 +56,19 @@ template<class Element> class TMatrixT : public TMatrixTBase<Element> {
 
 
    enum {kWorkMax = 100};
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
    enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kInverted,kAtA };
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
    enum EMatrixCreatorsOp2 { kMult,kTransposeMult,kInvMult,kMultTranspose,kPlus,kMinus };
 
    TMatrixT(): fDataStack(), fElements(nullptr) { }

math/matrix/inc/TMatrixTSparse.h

@@ -77,7 +77,19 @@ template<class Element> class TMatrixTSparse : public TMatrixTBase<Element> {
 
 public:
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
    enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kAtA };
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
    enum EMatrixCreatorsOp2 { kMult,kMultTranspose,kPlus,kMinus };
 
    TMatrixTSparse() { fElements = nullptr; fRowIndex = nullptr; fColIndex = nullptr; }

math/matrix/inc/TMatrixTSym.h

@@ -50,7 +50,19 @@ template<class Element> class TMatrixTSym : public TMatrixTBase<Element> {
 public:
 
    enum {kWorkMax = 100}; // size of work array
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
    enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kInverted,kAtA };
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
    enum EMatrixCreatorsOp2 { kPlus,kMinus };
 
    TMatrixTSym() { fElements = nullptr; }

tree/tree/inc/TBranch.h

@@ -56,7 +56,19 @@ class TBranchIMTHelper; ///< A helper class for managing IMT work during TTree:F
 const Int_t kDoNotProcess = BIT(10); // Active bit for branches
 const Int_t kIsClone      = BIT(11); // to indicate a TBranchClones
 const Int_t kBranchObject = BIT(12); // branch is a TObject*
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
 const Int_t kBranchAny    = BIT(17); // branch is an object*
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 const Int_t kMapObject    = kBranchObject | kBranchAny;
 
 namespace ROOT {