Convert ignoreUnused to [[maybe_unused]]

modules/juce_audio_basics/audio_play_head/juce_AudioPlayHead.cpp

@@ -0,0 +1,31 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2022 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   The code included in this file is provided under the terms of the ISC license
+   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
+   To use, copy, modify, and/or distribute this software for any purpose with or
+   without fee is hereby granted provided that the above copyright notice and
+   this permission notice appear in all copies.
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+bool AudioPlayHead::canControlTransport()                                          { return false; }
+void AudioPlayHead::transportPlay ([[maybe_unused]] bool shouldStartPlaying)       {}
+void AudioPlayHead::transportRecord ([[maybe_unused]] bool shouldStartRecording)   {}
+void AudioPlayHead::transportRewind()                                              {}
+
+} // namespace juce

modules/juce_audio_basics/audio_play_head/juce_AudioPlayHead.h

@@ -578,16 +578,16 @@ public:
     virtual Optional<PositionInfo> getPosition() const = 0;
 
     /** Returns true if this object can control the transport. */
-    virtual bool canControlTransport()                         { return false; }
+    virtual bool canControlTransport();
 
     /** Starts or stops the audio. */
-    virtual void transportPlay (bool shouldStartPlaying)       { ignoreUnused (shouldStartPlaying); }
+    virtual void transportPlay (bool shouldStartPlaying);
 
     /** Starts or stops recording the audio. */
-    virtual void transportRecord (bool shouldStartRecording)   { ignoreUnused (shouldStartRecording); }
+    virtual void transportRecord (bool shouldStartRecording);
 
     /** Rewinds the audio. */
-    virtual void transportRewind()                             {}
+    virtual void transportRewind();
 };
 
 } // namespace juce

modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

@@ -938,15 +938,13 @@ namespace
        #if JUCE_USE_VDSP_FRAMEWORK
         vDSP_vabs ((float*) src, 1, dest, 1, (vDSP_Length) num);
        #else
-        FloatVectorHelpers::signMask32 signMask;
+        [[maybe_unused]] FloatVectorHelpers::signMask32 signMask;
         signMask.i = 0x7fffffffUL;
         JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = std::abs (src[i]),
                                       Mode::bit_and (s, mask),
                                       JUCE_LOAD_SRC,
                                       JUCE_INCREMENT_SRC_DEST,
                                       const Mode::ParallelType mask = Mode::load1 (signMask.f);)
-
-        ignoreUnused (signMask);
        #endif
     }
 
@@ -956,7 +954,7 @@ namespace
        #if JUCE_USE_VDSP_FRAMEWORK
         vDSP_vabsD ((double*) src, 1, dest, 1, (vDSP_Length) num);
        #else
-        FloatVectorHelpers::signMask64 signMask;
+        [[maybe_unused]] FloatVectorHelpers::signMask64 signMask;
         signMask.i = 0x7fffffffffffffffULL;
 
         JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = std::abs (src[i]),
@@ -964,8 +962,6 @@ namespace
                                       JUCE_LOAD_SRC,
                                       JUCE_INCREMENT_SRC_DEST,
                                       const Mode::ParallelType mask = Mode::load1 (signMask.d);)
-
-        ignoreUnused (signMask);
        #endif
     }
 
@@ -1456,7 +1452,7 @@ intptr_t JUCE_CALLTYPE FloatVectorOperations::getFpStatusRegister() noexcept
     return fpsr;
 }
 
-void JUCE_CALLTYPE FloatVectorOperations::setFpStatusRegister (intptr_t fpsr) noexcept
+void JUCE_CALLTYPE FloatVectorOperations::setFpStatusRegister ([[maybe_unused]] intptr_t fpsr) noexcept
 {
  #if JUCE_INTEL && JUCE_USE_SSE_INTRINSICS
     // the volatile keyword here is needed to workaround a bug in AppleClang 13.0
@@ -1481,11 +1477,10 @@ void JUCE_CALLTYPE FloatVectorOperations::setFpStatusRegister (intptr_t fpsr) no
   #if ! (defined (JUCE_INTEL) || defined (JUCE_ARM))
     jassertfalse; // No support for getting the floating point status register for your platform
   #endif
-    ignoreUnused (fpsr);
  #endif
 }
 
-void JUCE_CALLTYPE FloatVectorOperations::enableFlushToZeroMode (bool shouldEnable) noexcept
+void JUCE_CALLTYPE FloatVectorOperations::enableFlushToZeroMode ([[maybe_unused]] bool shouldEnable) noexcept
 {
   #if JUCE_USE_SSE_INTRINSICS || (JUCE_USE_ARM_NEON || (JUCE_64BIT && JUCE_ARM))
    #if JUCE_USE_SSE_INTRINSICS
@@ -1498,11 +1493,10 @@ void JUCE_CALLTYPE FloatVectorOperations::enableFlushToZeroMode (bool shouldEnab
    #if ! (defined (JUCE_INTEL) || defined (JUCE_ARM))
     jassertfalse; // No support for flush to zero mode on your platform
    #endif
-    ignoreUnused (shouldEnable);
   #endif
 }
 
-void JUCE_CALLTYPE FloatVectorOperations::disableDenormalisedNumberSupport (bool shouldDisable) noexcept
+void JUCE_CALLTYPE FloatVectorOperations::disableDenormalisedNumberSupport ([[maybe_unused]] bool shouldDisable) noexcept
 {
   #if JUCE_USE_SSE_INTRINSICS || (JUCE_USE_ARM_NEON || (JUCE_64BIT && JUCE_ARM))
    #if JUCE_USE_SSE_INTRINSICS
@@ -1513,7 +1507,6 @@ void JUCE_CALLTYPE FloatVectorOperations::disableDenormalisedNumberSupport (bool
 
     setFpStatusRegister ((getFpStatusRegister() & (~mask)) | (shouldDisable ? mask : 0));
   #else
-    ignoreUnused (shouldDisable);
 
    #if ! (defined (JUCE_INTEL) || defined (JUCE_ARM))
     jassertfalse; // No support for disable denormals mode on your platform

modules/juce_audio_basics/juce_audio_basics.cpp

@@ -85,13 +85,16 @@
 #include "sources/juce_ResamplingAudioSource.cpp"
 #include "sources/juce_ReverbAudioSource.cpp"
 #include "sources/juce_ToneGeneratorAudioSource.cpp"
+#include "sources/juce_PositionableAudioSource.cpp"
 #include "synthesisers/juce_Synthesiser.cpp"
+#include "audio_play_head/juce_AudioPlayHead.cpp"
 
 #include "midi/ump/juce_UMP.h"
 #include "midi/ump/juce_UMPUtils.cpp"
 #include "midi/ump/juce_UMPView.cpp"
 #include "midi/ump/juce_UMPSysEx7.cpp"
 #include "midi/ump/juce_UMPMidi1ToMidi2DefaultTranslator.cpp"
+#include "midi/ump/juce_UMPIterator.cpp"
 
 #if JUCE_UNIT_TESTS
  #include "utilities/juce_ADSR_test.cpp"

modules/juce_audio_basics/midi/ump/juce_UMPIterator.cpp

@@ -0,0 +1,37 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2022 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   The code included in this file is provided under the terms of the ISC license
+   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
+   To use, copy, modify, and/or distribute this software for any purpose with or
+   without fee is hereby granted provided that the above copyright notice and
+   this permission notice appear in all copies.
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+namespace universal_midi_packets
+{
+
+Iterator::Iterator (const uint32_t* ptr, [[maybe_unused]] size_t bytes) noexcept
+    : view (ptr)
+   #if JUCE_DEBUG
+    , bytesRemaining (bytes)
+   #endif
+{
+}
+
+} // namespace universal_midi_packets
+} // namespace juce

modules/juce_audio_basics/midi/ump/juce_UMPIterator.h

@@ -43,14 +43,7 @@ public:
     Iterator() noexcept = default;
 
     /** Creates an iterator pointing at `ptr`. */
-    explicit Iterator (const uint32_t* ptr, size_t bytes) noexcept
+    explicit Iterator (const uint32_t* ptr, size_t bytes) noexcept;
-        : view (ptr)
-       #if JUCE_DEBUG
-        , bytesRemaining (bytes)
-       #endif
-    {
-        ignoreUnused (bytes);
-    }
 
     using difference_type    = std::iterator_traits<const uint32_t*>::difference_type;
     using value_type         = View;
@@ -124,7 +117,7 @@ private:
    #endif
 };
 
-}
+} // namespace universal_midi_packets
-}
+} // namespace juce
 
 #endif

modules/juce_audio_basics/mpe/juce_MPEInstrument.cpp

@@ -853,6 +853,14 @@ void MPEInstrument::releaseAllNotes()
     notes.clear();
 }
 
+//==============================================================================
+void MPEInstrument::Listener::noteAdded ([[maybe_unused]] MPENote newNote)                 {}
+void MPEInstrument::Listener::notePressureChanged  ([[maybe_unused]] MPENote changedNote)  {}
+void MPEInstrument::Listener::notePitchbendChanged ([[maybe_unused]] MPENote changedNote)  {}
+void MPEInstrument::Listener::noteTimbreChanged    ([[maybe_unused]] MPENote changedNote)  {}
+void MPEInstrument::Listener::noteKeyStateChanged  ([[maybe_unused]] MPENote changedNote)  {}
+void MPEInstrument::Listener::noteReleased ([[maybe_unused]] MPENote finishedNote)         {}
+void MPEInstrument::Listener::zoneLayoutChanged()                                          {}
 
 //==============================================================================
 //==============================================================================

modules/juce_audio_basics/mpe/juce_MPEInstrument.h

@@ -265,12 +265,12 @@ public:
         /** Implement this callback to be informed whenever a new expressive MIDI
             note is triggered.
         */
-        virtual void noteAdded (MPENote newNote)                 { ignoreUnused (newNote); }
+        virtual void noteAdded (MPENote newNote);
 
         /** Implement this callback to be informed whenever a currently playing
             MPE note's pressure value changes.
         */
-        virtual void notePressureChanged (MPENote changedNote)   { ignoreUnused (changedNote); }
+        virtual void notePressureChanged (MPENote changedNote);
 
         /** Implement this callback to be informed whenever a currently playing
             MPE note's pitchbend value changes.
@@ -279,12 +279,12 @@ public:
             master channel pitchbend event, or if both occur simultaneously.
             Call MPENote::getFrequencyInHertz to get the effective note frequency.
         */
-        virtual void notePitchbendChanged (MPENote changedNote)  { ignoreUnused (changedNote); }
+        virtual void notePitchbendChanged (MPENote changedNote);
 
         /** Implement this callback to be informed whenever a currently playing
             MPE note's timbre value changes.
         */
-        virtual void noteTimbreChanged (MPENote changedNote)     { ignoreUnused (changedNote); }
+        virtual void noteTimbreChanged (MPENote changedNote);
 
         /** Implement this callback to be informed whether a currently playing
             MPE note's key state (whether the key is down and/or the note is
@@ -293,19 +293,19 @@ public:
             Note: If the key state changes to MPENote::off, noteReleased is
             called instead.
         */
-        virtual void noteKeyStateChanged (MPENote changedNote)   { ignoreUnused (changedNote); }
+        virtual void noteKeyStateChanged (MPENote changedNote);
 
         /** Implement this callback to be informed whenever an MPE note
             is released (either by a note-off message, or by a sustain/sostenuto
             pedal release for a note that already received a note-off),
             and should therefore stop playing.
         */
-        virtual void noteReleased (MPENote finishedNote)         { ignoreUnused (finishedNote); }
+        virtual void noteReleased (MPENote finishedNote);
 
         /** Implement this callback to be informed whenever the MPE zone layout
             or legacy mode settings of this instrument have been changed.
         */
-        virtual void zoneLayoutChanged()                         {}
+        virtual void zoneLayoutChanged();
     };
 
     //==============================================================================

modules/juce_audio_basics/sources/juce_PositionableAudioSource.cpp

@@ -0,0 +1,28 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2022 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   The code included in this file is provided under the terms of the ISC license
+   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
+   To use, copy, modify, and/or distribute this software for any purpose with or
+   without fee is hereby granted provided that the above copyright notice and
+   this permission notice appear in all copies.
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+void PositionableAudioSource::setLooping ([[maybe_unused]] bool shouldLoop) {}
+
+} // namespace juce

modules/juce_audio_basics/sources/juce_PositionableAudioSource.h

@@ -70,7 +70,7 @@ public:
     virtual bool isLooping() const = 0;
 
     /** Tells the source whether you'd like it to play in a loop. */
-    virtual void setLooping (bool shouldLoop)       { ignoreUnused (shouldLoop); }
+    virtual void setLooping (bool shouldLoop);
 };
 
 } // namespace juce

modules/juce_audio_basics/synthesisers/juce_Synthesiser.cpp

@@ -482,15 +482,14 @@ void Synthesiser::handleSostenutoPedal (int midiChannel, bool isDown)
     }
 }
 
-void Synthesiser::handleSoftPedal (int midiChannel, bool /*isDown*/)
+void Synthesiser::handleSoftPedal ([[maybe_unused]] int midiChannel, bool /*isDown*/)
 {
-    ignoreUnused (midiChannel);
     jassert (midiChannel > 0 && midiChannel <= 16);
 }
 
-void Synthesiser::handleProgramChange (int midiChannel, int programNumber)
+void Synthesiser::handleProgramChange ([[maybe_unused]] int midiChannel,
+                                       [[maybe_unused]] int programNumber)
 {
-    ignoreUnused (midiChannel, programNumber);
     jassert (midiChannel > 0 && midiChannel <= 16);
 }
 

modules/juce_audio_devices/audio_io/juce_AudioIODevice.cpp

@@ -23,6 +23,14 @@
 namespace juce
 {
 
+void AudioIODeviceCallback::audioDeviceIOCallbackWithContext ([[maybe_unused]] const float* const* inputChannelData,
+                                                              [[maybe_unused]] int numInputChannels,
+                                                              [[maybe_unused]] float* const* outputChannelData,
+                                                              [[maybe_unused]] int numOutputChannels,
+                                                              [[maybe_unused]] int numSamples,
+                                                              [[maybe_unused]] const AudioIODeviceCallbackContext& context) {}
+
+//==============================================================================
 AudioIODevice::AudioIODevice (const String& deviceName, const String& deviceTypeName)
     : name (deviceName), typeName (deviceTypeName)
 {

modules/juce_audio_devices/audio_io/juce_AudioIODevice.h

@@ -98,10 +98,7 @@ public:
                                                    float* const* outputChannelData,
                                                    int numOutputChannels,
                                                    int numSamples,
-                                                   const AudioIODeviceCallbackContext& context)
+                                                   const AudioIODeviceCallbackContext& context);
-    {
-        ignoreUnused (inputChannelData, numInputChannels, outputChannelData, numOutputChannels, numSamples, context);
-    }
 
     /** Called to indicate that the device is about to start calling back.
 
@@ -129,7 +126,6 @@ public:
     virtual void audioDeviceError (const String& errorMessage);
 };
 
-
 //==============================================================================
 /**
     Base class for an audio device with synchronised input and output channels.

modules/juce_audio_devices/midi_io/juce_MidiDevices.cpp

@@ -23,6 +23,12 @@
 namespace juce
 {
 
+void MidiInputCallback::handlePartialSysexMessage ([[maybe_unused]] MidiInput* source,
+                                                   [[maybe_unused]] const uint8* messageData,
+                                                   [[maybe_unused]] int numBytesSoFar,
+                                                   [[maybe_unused]] double timestamp) {}
+
+//==============================================================================
 MidiOutput::MidiOutput (const String& deviceName, const String& deviceIdentifier)
     : Thread ("midi out"), deviceInfo (deviceName, deviceIdentifier)
 {

modules/juce_audio_devices/midi_io/juce_MidiDevices.h

@@ -225,10 +225,7 @@ public:
     virtual void handlePartialSysexMessage (MidiInput* source,
                                             const uint8* messageData,
                                             int numBytesSoFar,
-                                            double timestamp)
+                                            double timestamp);
-    {
-        ignoreUnused (source, messageData, numBytesSoFar, timestamp);
-    }
 };
 
 //==============================================================================

modules/juce_audio_devices/native/juce_android_Oboe.cpp

@@ -596,8 +596,7 @@ private:
         {
             if (stream != nullptr)
             {
-                oboe::Result result = stream->close();
+                [[maybe_unused]] oboe::Result result = stream->close();
-                ignoreUnused (result);
                 JUCE_OBOE_LOG ("Requested Oboe stream close with result: " + getOboeString (result));
             }
         }
@@ -693,14 +692,15 @@ private:
         }
 
         // Not strictly required as these should not change, but recommended by Google anyway
-        void checkStreamSetup (OboeStream* stream, int deviceId, int numChannels, int expectedSampleRate,
+        void checkStreamSetup (OboeStream* stream,
-                               int expectedBufferSize, oboe::AudioFormat format)
+                               [[maybe_unused]] int deviceId,
+                               [[maybe_unused]] int numChannels,
+                               [[maybe_unused]] int expectedSampleRate,
+                               [[maybe_unused]] int expectedBufferSize,
+                               oboe::AudioFormat format)
         {
-            if (auto* nativeStream = stream != nullptr ? stream->getNativeStream() : nullptr)
+            if ([[maybe_unused]] auto* nativeStream = stream != nullptr ? stream->getNativeStream() : nullptr)
             {
-                ignoreUnused (deviceId, numChannels, sampleRate, expectedBufferSize);
-                ignoreUnused (streamFormat, bitDepth);
-
                 jassert (numChannels == 0 || numChannels == nativeStream->getChannelCount());
                 jassert (expectedSampleRate == 0 || expectedSampleRate == nativeStream->getSampleRate());
                 jassert (format == nativeStream->getFormat());
@@ -860,10 +860,8 @@ private:
             return oboe::DataCallbackResult::Continue;
         }
 
-        void printStreamDebugInfo (oboe::AudioStream* stream)
+        void printStreamDebugInfo ([[maybe_unused]] oboe::AudioStream* stream)
         {
-            ignoreUnused (stream);
-
             JUCE_OBOE_LOG ("\nUses AAudio = " + (stream != nullptr ? String ((int) stream->usesAAudio()) : String ("?"))
                  + "\nDirection = " + (stream != nullptr ? getOboeString (stream->getDirection()) : String ("?"))
                  + "\nSharingMode = " + (stream != nullptr ? getOboeString (stream->getSharingMode()) : String ("?"))
@@ -928,10 +926,8 @@ private:
             return time.tv_sec * oboe::kNanosPerSecond + time.tv_nsec;
         }
 
-        void onErrorBeforeClose (oboe::AudioStream* stream, oboe::Result error) override
+        void onErrorBeforeClose (oboe::AudioStream* stream, [[maybe_unused]] oboe::Result error) override
         {
-            ignoreUnused (error);
-
             // only output stream should be the master stream receiving callbacks
             jassert (stream->getDirection() == oboe::Direction::Output);
 
@@ -1167,10 +1163,8 @@ public:
 
         JUCE_OBOE_LOG ("-----InputDevices:");
 
-        for (auto& device : inputDevices)
+        for ([[maybe_unused]] auto& device : inputDevices)
         {
-            ignoreUnused (device);
-
             JUCE_OBOE_LOG ("name = " << device.name);
             JUCE_OBOE_LOG ("id = " << String (device.id));
             JUCE_OBOE_LOG ("sample rates size = " << String (device.sampleRates.size()));
@@ -1179,10 +1173,8 @@ public:
 
         JUCE_OBOE_LOG ("-----OutputDevices:");
 
-        for (auto& device : outputDevices)
+        for ([[maybe_unused]] auto& device : outputDevices)
         {
-            ignoreUnused (device);
-
             JUCE_OBOE_LOG ("name = " << device.name);
             JUCE_OBOE_LOG ("id = " << String (device.id));
             JUCE_OBOE_LOG ("sample rates size = " << String (device.sampleRates.size()));
@@ -1392,17 +1384,15 @@ public:
         return oboe::DataCallbackResult::Continue;
     }
 
-    void onErrorBeforeClose (oboe::AudioStream*, oboe::Result error) override
+    void onErrorBeforeClose (oboe::AudioStream*, [[maybe_unused]] oboe::Result error) override
     {
         JUCE_OBOE_LOG ("OboeRealtimeThread: Oboe stream onErrorBeforeClose(): " + getOboeString (error));
-        ignoreUnused (error);
         jassertfalse;  // Should never get here!
     }
 
-    void onErrorAfterClose (oboe::AudioStream*, oboe::Result error) override
+    void onErrorAfterClose (oboe::AudioStream*, [[maybe_unused]] oboe::Result error) override
     {
         JUCE_OBOE_LOG ("OboeRealtimeThread: Oboe stream onErrorAfterClose(): " + getOboeString (error));
-        ignoreUnused (error);
         jassertfalse;  // Should never get here!
     }
 

modules/juce_audio_devices/native/juce_ios_Audio.cpp

@@ -579,7 +579,7 @@ struct iOSAudioIODevice::Pimpl      : public AsyncUpdater
             impl.fillHostCallbackInfo (callbackInfo);
 
             Boolean hostIsPlaying = NO;
-            OSStatus err = callbackInfo.transportStateProc2 (callbackInfo.hostUserData,
+            [[maybe_unused]] OSStatus err = callbackInfo.transportStateProc2 (callbackInfo.hostUserData,
                                                                               &hostIsPlaying,
                                                                               nullptr,
                                                                               nullptr,
@@ -588,7 +588,6 @@ struct iOSAudioIODevice::Pimpl      : public AsyncUpdater
                                                                               nullptr,
                                                                               nullptr);
 
-            ignoreUnused (err);
             jassert (err == noErr);
 
             if (hostIsPlaying != shouldSartPlaying)
@@ -604,7 +603,7 @@ struct iOSAudioIODevice::Pimpl      : public AsyncUpdater
             impl.fillHostCallbackInfo (callbackInfo);
 
             Boolean hostIsRecording = NO;
-            OSStatus err = callbackInfo.transportStateProc2 (callbackInfo.hostUserData,
+            [[maybe_unused]] OSStatus err = callbackInfo.transportStateProc2 (callbackInfo.hostUserData,
                                                                               nullptr,
                                                                               &hostIsRecording,
                                                                               nullptr,
@@ -612,7 +611,6 @@ struct iOSAudioIODevice::Pimpl      : public AsyncUpdater
                                                                               nullptr,
                                                                               nullptr,
                                                                               nullptr);
-            ignoreUnused (err);
             jassert (err == noErr);
 
             if (hostIsRecording != shouldStartRecording)
@@ -808,11 +806,9 @@ struct iOSAudioIODevice::Pimpl      : public AsyncUpdater
 
     void handleAudioUnitPropertyChange (AudioUnit,
                                         AudioUnitPropertyID propertyID,
-                                        AudioUnitScope scope,
+                                        [[maybe_unused]] AudioUnitScope scope,
-                                        AudioUnitElement element)
+                                        [[maybe_unused]] AudioUnitElement element)
     {
-        ignoreUnused (scope);
-        ignoreUnused (element);
         JUCE_IOS_AUDIO_LOG ("handleAudioUnitPropertyChange: propertyID: " << String (propertyID)
                                                             << " scope: " << String (scope)
                                                           << " element: " << String (element));
@@ -834,9 +830,8 @@ struct iOSAudioIODevice::Pimpl      : public AsyncUpdater
     {
         UInt32 connected;
         UInt32 dataSize = sizeof (connected);
-        OSStatus err = AudioUnitGetProperty (audioUnit, kAudioUnitProperty_IsInterAppConnected,
+        [[maybe_unused]] OSStatus err = AudioUnitGetProperty (audioUnit, kAudioUnitProperty_IsInterAppConnected,
                                                               kAudioUnitScope_Global, 0, &connected, &dataSize);
-        ignoreUnused (err);
         jassert (err == noErr);
 
         JUCE_IOS_AUDIO_LOG ("handleInterAppAudioConnectionChange: " << (connected ? "connected"
@@ -1078,21 +1073,19 @@ struct iOSAudioIODevice::Pimpl      : public AsyncUpdater
     {
         zerostruct (callbackInfo);
         UInt32 dataSize = sizeof (HostCallbackInfo);
-        OSStatus err = AudioUnitGetProperty (audioUnit,
+        [[maybe_unused]] OSStatus err = AudioUnitGetProperty (audioUnit,
                                                               kAudioUnitProperty_HostCallbacks,
                                                               kAudioUnitScope_Global,
                                                               0,
                                                               &callbackInfo,
                                                               &dataSize);
-        ignoreUnused (err);
         jassert (err == noErr);
     }
 
     void handleAudioTransportEvent (AudioUnitRemoteControlEvent event)
     {
-        OSStatus err = AudioUnitSetProperty (audioUnit, kAudioOutputUnitProperty_RemoteControlToHost,
+        [[maybe_unused]] OSStatus err = AudioUnitSetProperty (audioUnit, kAudioOutputUnitProperty_RemoteControlToHost,
                                                               kAudioUnitScope_Global, 0, &event, sizeof (event));
-        ignoreUnused (err);
         jassert (err == noErr);
     }
 

modules/juce_audio_devices/native/juce_linux_JackAudio.cpp

@@ -544,21 +544,19 @@ private:
         }
     }
 
-    static void infoShutdownCallback (jack_status_t code, const char* reason, void* arg)
+    static void infoShutdownCallback (jack_status_t code, [[maybe_unused]] const char* reason, void* arg)
     {
         jassertquiet (code == 0);
 
         JUCE_JACK_LOG ("Shutting down with message:");
         JUCE_JACK_LOG (reason);
-        ignoreUnused (reason);
 
         shutdownCallback (arg);
     }
 
-    static void errorCallback (const char* msg)
+    static void errorCallback ([[maybe_unused]] const char* msg)
     {
         JUCE_JACK_LOG ("JackAudioIODevice::errorCallback " + String (msg));
-        ignoreUnused (msg);
     }
 
     bool deviceIsOpen = false;

modules/juce_audio_devices/native/juce_mac_CoreMidi.mm

@@ -29,7 +29,7 @@ namespace juce
 
 namespace CoreMidiHelpers
 {
-    static bool checkError (OSStatus err, int lineNum)
+    static bool checkError (OSStatus err, [[maybe_unused]] int lineNum)
     {
         if (err == noErr)
             return true;
@@ -38,7 +38,6 @@ namespace CoreMidiHelpers
         Logger::writeToLog ("CoreMIDI error: " + String (lineNum) + " - " + String::toHexString ((int) err));
        #endif
 
-        ignoreUnused (lineNum);
         return false;
     }
 

modules/juce_audio_devices/native/juce_win32_DirectSound.cpp

@@ -251,8 +251,8 @@ public:
         if (pOutputBuffer != nullptr)
         {
             JUCE_DS_LOG ("closing output: " + name);
-            HRESULT hr = pOutputBuffer->Stop();
+            [[maybe_unused]] HRESULT hr = pOutputBuffer->Stop();
-            JUCE_DS_LOG_ERROR (hr); ignoreUnused (hr);
+            JUCE_DS_LOG_ERROR (hr);
 
             pOutputBuffer->Release();
             pOutputBuffer = nullptr;
@@ -555,8 +555,8 @@ public:
         if (pInputBuffer != nullptr)
         {
             JUCE_DS_LOG ("closing input: " + name);
-            HRESULT hr = pInputBuffer->Stop();
+            [[maybe_unused]] HRESULT hr = pInputBuffer->Stop();
-            JUCE_DS_LOG_ERROR (hr); ignoreUnused (hr);
+            JUCE_DS_LOG_ERROR (hr);
 
             pInputBuffer->Release();
             pInputBuffer = nullptr;

modules/juce_audio_devices/native/juce_win32_WASAPI.cpp

@@ -33,9 +33,8 @@ JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wlanguage-extension-token")
 namespace WasapiClasses
 {
 
-static void logFailure (HRESULT hr)
+static void logFailure ([[maybe_unused]] HRESULT hr)
 {
-    ignoreUnused (hr);
     jassert (hr != (HRESULT) 0x800401f0); // If you hit this, it means you're trying to call from
                                           // a thread which hasn't been initialised with CoInitialize().
 

modules/juce_audio_devices/sources/juce_AudioSourcePlayer.cpp

@@ -61,10 +61,8 @@ void AudioSourcePlayer::audioDeviceIOCallbackWithContext (const float* const* in
                                                           float* const* outputChannelData,
                                                           int totalNumOutputChannels,
                                                           int numSamples,
-                                                          const AudioIODeviceCallbackContext& context)
+                                                          [[maybe_unused]] const AudioIODeviceCallbackContext& context)
 {
-    ignoreUnused (context);
-
     // these should have been prepared by audioDeviceAboutToStart()...
     jassert (sampleRate > 0 && bufferSize > 0);
 

modules/juce_audio_formats/codecs/juce_AiffAudioFormat.cpp

@@ -721,8 +721,7 @@ private:
     {
         using namespace AiffFileHelpers;
 
-        const bool couldSeekOk = output->setPosition (headerPosition);
+        [[maybe_unused]] const bool couldSeekOk = output->setPosition (headerPosition);
-        ignoreUnused (couldSeekOk);
 
         // if this fails, you've given it an output stream that can't seek! It needs
         // to be able to seek back to write the header

modules/juce_audio_formats/codecs/juce_FlacAudioFormat.cpp

@@ -496,8 +496,7 @@ public:
         packUint32 ((FLAC__uint32) info.total_samples, buffer + 14, 4);
         memcpy (buffer + 18, info.md5sum, 16);
 
-        const bool seekOk = output->setPosition (streamStartPos + 4);
+        [[maybe_unused]] const bool seekOk = output->setPosition (streamStartPos + 4);
-        ignoreUnused (seekOk);
 
         // if this fails, you've given it an output stream that can't seek! It needs
         // to be able to seek back to write the header

modules/juce_audio_formats/codecs/juce_LAMEEncoderAudioFormat.cpp

@@ -112,8 +112,8 @@ private:
 
         if (cp.start (processArgs))
         {
-            auto childOutput = cp.readAllProcessOutput();
+            [[maybe_unused]] auto childOutput = cp.readAllProcessOutput();
-            DBG (childOutput); ignoreUnused (childOutput);
+            DBG (childOutput);
 
             cp.waitForProcessToFinish (10000);
             return tempMP3.getFile().getSize() > 0;

modules/juce_audio_formats/codecs/juce_WindowsMediaAudioFormat.cpp

@@ -262,7 +262,7 @@ private:
 
     void checkCoInitialiseCalled()
     {
-        ignoreUnused (CoInitialize (nullptr));
+        [[maybe_unused]] const auto result = CoInitialize (nullptr);
     }
 
     void scanFileForDetails()

modules/juce_audio_plugin_client/AAX/juce_AAX_Wrapper.cpp

@@ -1499,11 +1499,10 @@ namespace AAXClasses
         friend void AAX_CALLBACK AAXClasses::algorithmProcessCallback (JUCEAlgorithmContext* const instancesBegin[], const void* const instancesEnd);
 
         void process (float* const* channels, const int numChans, const int bufferSize,
-                      const bool bypass, AAX_IMIDINode* midiNodeIn, AAX_IMIDINode* midiNodesOut)
+                      const bool bypass, [[maybe_unused]] AAX_IMIDINode* midiNodeIn, [[maybe_unused]] AAX_IMIDINode* midiNodesOut)
         {
             AudioBuffer<float> buffer (channels, numChans, bufferSize);
             midiBuffer.clear();
-            ignoreUnused (midiNodeIn, midiNodesOut);
 
            #if JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect
             {
@@ -2391,7 +2390,7 @@ namespace AAXClasses
         return (AAX_STEM_FORMAT_INDEX (stemFormat) <= 12);
     }
 
-    static void getPlugInDescription (AAX_IEffectDescriptor& descriptor, const AAX_IFeatureInfo* featureInfo)
+    static void getPlugInDescription (AAX_IEffectDescriptor& descriptor, [[maybe_unused]] const AAX_IFeatureInfo* featureInfo)
     {
         PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_AAX;
         std::unique_ptr<AudioProcessor> plugin (createPluginFilterOfType (AudioProcessor::wrapperType_AAX));
@@ -2424,7 +2423,6 @@ namespace AAXClasses
        #if JucePlugin_IsMidiEffect
         // MIDI effect plug-ins do not support any audio channels
         jassert (numInputBuses == 0 && numOutputBuses == 0);
-        ignoreUnused (featureInfo);
 
         if (auto* desc = descriptor.NewComponentDescriptor())
         {

modules/juce_audio_plugin_client/AU/juce_AU_Wrapper.mm

@@ -242,11 +242,9 @@ public:
     }
 
     //==============================================================================
-    bool BusCountWritable (AudioUnitScope scope) override
+    bool BusCountWritable ([[maybe_unused]] AudioUnitScope scope) override
     {
        #ifdef JucePlugin_PreferredChannelConfigurations
-        ignoreUnused (scope);
-
         return false;
        #else
         bool isInput;
@@ -774,11 +772,9 @@ public:
     }
 
     //==============================================================================
-    bool busIgnoresLayout (bool isInput, int busNr) const
+    bool busIgnoresLayout ([[maybe_unused]] bool isInput, [[maybe_unused]] int busNr) const
     {
        #ifdef JucePlugin_PreferredChannelConfigurations
-        ignoreUnused (isInput, busNr);
-
         return true;
        #else
         if (const AudioProcessor::Bus* bus = juceFilter->getBus (isInput, busNr))
@@ -878,10 +874,9 @@ public:
 
     //==============================================================================
     // When parameters are discrete we need to use integer values.
-    float getMaximumParameterValue (AudioProcessorParameter* juceParam)
+    float getMaximumParameterValue ([[maybe_unused]] AudioProcessorParameter* juceParam)
     {
        #if JUCE_FORCE_LEGACY_PARAMETER_AUTOMATION_TYPE
-        ignoreUnused (juceParam);
         return 1.0f;
        #else
         return juceParam->isDiscrete() ? (float) (juceParam->getNumSteps() - 1) : 1.0f;
@@ -1234,7 +1229,7 @@ public:
         if (newNumChannels == oldNumChannels)
             return true;
 
-        if (AudioProcessor::Bus* bus = juceFilter->getBus (info.isInput, info.busNr))
+        if ([[maybe_unused]] AudioProcessor::Bus* bus = juceFilter->getBus (info.isInput, info.busNr))
         {
             if (! MusicDeviceBase::ValidFormat (inScope, inElement, inNewFormat))
                 return false;
@@ -1242,7 +1237,6 @@ public:
            #ifdef JucePlugin_PreferredChannelConfigurations
             short configs[][2] = {JucePlugin_PreferredChannelConfigurations};
 
-            ignoreUnused (bus);
             return AudioUnitHelpers::isLayoutSupported (*juceFilter, info.isInput, info.busNr, newNumChannels, configs);
            #else
             return bus->isNumberOfChannelsSupported (newNumChannels);
@@ -1395,7 +1389,11 @@ public:
     ComponentResult StopNote (MusicDeviceGroupID, NoteInstanceID, UInt32) override   { return noErr; }
 
     //==============================================================================
-    OSStatus HandleMIDIEvent (UInt8 inStatus, UInt8 inChannel, UInt8 inData1, UInt8 inData2, UInt32 inStartFrame) override
+    OSStatus HandleMIDIEvent ([[maybe_unused]] UInt8 inStatus,
+                              [[maybe_unused]] UInt8 inChannel,
+                              [[maybe_unused]] UInt8 inData1,
+                              [[maybe_unused]] UInt8 inData2,
+                              [[maybe_unused]] UInt32 inStartFrame) override
     {
        #if JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect
         const juce::uint8 data[] = { (juce::uint8) (inStatus | inChannel),
@@ -1406,20 +1404,17 @@ public:
         incomingEvents.addEvent (data, 3, (int) inStartFrame);
         return noErr;
        #else
-        ignoreUnused (inStatus, inChannel, inData1);
-        ignoreUnused (inData2, inStartFrame);
         return kAudioUnitErr_PropertyNotInUse;
        #endif
     }
 
-    OSStatus HandleSysEx (const UInt8* inData, UInt32 inLength) override
+    OSStatus HandleSysEx ([[maybe_unused]] const UInt8* inData, [[maybe_unused]] UInt32 inLength) override
     {
        #if JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect
         const ScopedLock sl (incomingMidiLock);
         incomingEvents.addEvent (inData, (int) inLength, 0);
         return noErr;
        #else
-        ignoreUnused (inData, inLength);
         return kAudioUnitErr_PropertyNotInUse;
        #endif
     }
@@ -1950,7 +1945,7 @@ private:
         }
     }
 
-    void pushMidiOutput (UInt32 nFrames) noexcept
+    void pushMidiOutput ([[maybe_unused]] UInt32 nFrames) noexcept
     {
         MIDIPacket* end = nullptr;
 
@@ -1979,7 +1974,6 @@ private:
         for (const auto metadata : midiEvents)
         {
             jassert (isPositiveAndBelow (metadata.samplePosition, nFrames));
-            ignoreUnused (nFrames);
 
             add (metadata);
 

modules/juce_audio_plugin_client/AU/juce_AUv3_Wrapper.mm

@@ -359,11 +359,9 @@ public:
 
         AudioProcessor& processor = getAudioProcessor();
 
-        if (AudioProcessor::Bus* bus = processor.getBus (isInput, busIdx))
+        if ([[maybe_unused]] AudioProcessor::Bus* bus = processor.getBus (isInput, busIdx))
         {
           #ifdef JucePlugin_PreferredChannelConfigurations
-            ignoreUnused (bus);
-
             short configs[][2] = {JucePlugin_PreferredChannelConfigurations};
 
             if (! AudioUnitHelpers::isLayoutSupported (processor, isInput, busIdx, newNumChannels, configs))
@@ -603,10 +601,8 @@ public:
     };
 
     //==============================================================================
-    void audioProcessorChanged (AudioProcessor* processor, const ChangeDetails& details) override
+    void audioProcessorChanged ([[maybe_unused]] AudioProcessor* processor, const ChangeDetails& details) override
     {
-        ignoreUnused (processor);
-
         if (! details.programChanged)
             return;
 
@@ -1109,10 +1105,9 @@ private:
     }
 
     // When parameters are discrete we need to use integer values.
-    float getMaximumParameterValue (AudioProcessorParameter* juceParam) const
+    float getMaximumParameterValue ([[maybe_unused]] AudioProcessorParameter* juceParam) const
     {
        #if JUCE_FORCE_LEGACY_PARAMETER_AUTOMATION_TYPE
-        ignoreUnused (juceParam);
         return 1.0f;
        #else
         return juceParam->isDiscrete() ? (float) (juceParam->getNumSteps() - 1) : 1.0f;
@@ -1355,10 +1350,8 @@ private:
     }
 
     //==============================================================================
-    void processEvents (const AURenderEvent *__nullable realtimeEventListHead, int numParams, AUEventSampleTime startTime)
+    void processEvents (const AURenderEvent *__nullable realtimeEventListHead, [[maybe_unused]] int numParams, AUEventSampleTime startTime)
     {
-        ignoreUnused (numParams);
-
         for (const AURenderEvent* event = realtimeEventListHead; event != nullptr; event = event->head.next)
         {
             switch (event->head.eventType)

modules/juce_audio_plugin_client/Standalone/juce_StandaloneFilterWindow.h

@@ -386,13 +386,12 @@ public:
         return false;
     }
 
-    Image getIAAHostIcon (int size)
+    Image getIAAHostIcon ([[maybe_unused]] int size)
     {
        #if JUCE_IOS && JucePlugin_Enable_IAA
         if (auto device = dynamic_cast<iOSAudioIODevice*> (deviceManager.getCurrentAudioDevice()))
             return device->getIcon (size);
        #else
-        ignoreUnused (size);
        #endif
 
         return {};

modules/juce_audio_plugin_client/Unity/juce_Unity_Wrapper.cpp

@@ -158,10 +158,8 @@ private:
             return std::make_unique<LowLevelGraphicsSoftwareRenderer> (Image (this));
         }
 
-        void initialiseBitmapData (Image::BitmapData& bitmap, int x, int y, Image::BitmapData::ReadWriteMode mode) override
+        void initialiseBitmapData (Image::BitmapData& bitmap, int x, int y, [[maybe_unused]] Image::BitmapData::ReadWriteMode mode) override
         {
-            ignoreUnused (mode);
-
             const auto offset = (size_t) x * (size_t) pixelStride + (size_t) y * (size_t) lineStride;
             bitmap.data = imageData + offset;
             bitmap.size = (size_t) (lineStride * height) - offset;
@@ -568,7 +566,6 @@ static UnityAudioEffectDefinition getEffectDefinition()
     result.setPosition = [] (UnityAudioEffectState* state, unsigned int pos)
     {
         ignoreUnused (state, pos);
-
         return 0;
     };
 

modules/juce_audio_plugin_client/VST/juce_VST_Wrapper.cpp

@@ -962,14 +962,12 @@ public:
                               , public Timer
                              #endif
     {
-        EditorCompWrapper (JuceVSTWrapper& w, AudioProcessorEditor& editor, float initialScale)
+        EditorCompWrapper (JuceVSTWrapper& w, AudioProcessorEditor& editor, [[maybe_unused]] float initialScale)
             : wrapper (w)
         {
             editor.setOpaque (true);
            #if ! JUCE_MAC
             editor.setScaleFactor (initialScale);
-           #else
-            ignoreUnused (initialScale);
            #endif
             addAndMakeVisible (editor);
 
@@ -1714,13 +1712,12 @@ private:
         return 0;
     }
 
-    pointer_sized_int handlePreAudioProcessingEvents (VstOpCodeArguments args)
+    pointer_sized_int handlePreAudioProcessingEvents ([[maybe_unused]] VstOpCodeArguments args)
     {
        #if JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect
         VSTMidiEventList::addEventsToMidiBuffer ((Vst2::VstEvents*) args.ptr, midiEvents);
         return 1;
        #else
-        ignoreUnused (args);
         return 0;
        #endif
     }
@@ -2013,7 +2010,7 @@ private:
         return 0;
     }
 
-    pointer_sized_int handleSetContentScaleFactor (float scale, bool force = false)
+    pointer_sized_int handleSetContentScaleFactor ([[maybe_unused]] float scale, [[maybe_unused]] bool force = false)
     {
         checkWhetherMessageThreadIsCorrect();
        #if JUCE_LINUX || JUCE_BSD
@@ -2030,9 +2027,6 @@ private:
             if (editorComp != nullptr)
                 editorComp->setContentScaleFactor (editorScaleFactor);
         }
-
-       #else
-        ignoreUnused (scale, force);
        #endif
 
         return 1;

modules/juce_audio_plugin_client/VST/juce_VST_Wrapper.mm

@@ -80,7 +80,7 @@ void initialiseMacVST()
 }
 
 JUCE_API void* attachComponentToWindowRefVST (Component* comp, void* parentWindowOrView, bool isNSView);
-void* attachComponentToWindowRefVST (Component* comp, void* parentWindowOrView, bool isNSView)
+void* attachComponentToWindowRefVST (Component* comp, void* parentWindowOrView, [[maybe_unused]] bool isNSView)
 {
     JUCE_AUTORELEASEPOOL
     {
@@ -161,7 +161,6 @@ void* attachComponentToWindowRefVST (Component* comp, void* parentWindowOrView,
         }
        #endif
 
-        ignoreUnused (isNSView);
         NSView* parentView = [(NSView*) parentWindowOrView retain];
 
        #if JucePlugin_EditorRequiresKeyboardFocus
@@ -183,7 +182,7 @@ void* attachComponentToWindowRefVST (Component* comp, void* parentWindowOrView,
 }
 
 JUCE_API void detachComponentFromWindowRefVST (Component* comp, void* window, bool isNSView);
-void detachComponentFromWindowRefVST (Component* comp, void* window, bool isNSView)
+void detachComponentFromWindowRefVST (Component* comp, void* window, [[maybe_unused]] bool isNSView)
 {
     JUCE_AUTORELEASEPOOL
     {
@@ -232,14 +231,13 @@ void detachComponentFromWindowRefVST (Component* comp, void* window, bool isNSVi
         }
        #endif
 
-        ignoreUnused (isNSView);
         comp->removeFromDesktop();
         [(id) window release];
     }
 }
 
 JUCE_API void setNativeHostWindowSizeVST (void* window, Component* component, int newWidth, int newHeight, bool isNSView);
-void setNativeHostWindowSizeVST (void* window, Component* component, int newWidth, int newHeight, bool isNSView)
+void setNativeHostWindowSizeVST (void* window, Component* component, int newWidth, int newHeight, [[maybe_unused]] bool isNSView)
 {
     JUCE_AUTORELEASEPOOL
     {
@@ -260,8 +258,6 @@ void setNativeHostWindowSizeVST (void* window, Component* component, int newWidt
         }
        #endif
 
-        ignoreUnused (isNSView);
-
         if (NSView* hostView = (NSView*) window)
         {
             const int dx = newWidth  - component->getWidth();
@@ -277,10 +273,10 @@ void setNativeHostWindowSizeVST (void* window, Component* component, int newWidt
 }
 
 JUCE_API void checkWindowVisibilityVST (void* window, Component* comp, bool isNSView);
-void checkWindowVisibilityVST (void* window, Component* comp, bool isNSView)
+void checkWindowVisibilityVST ([[maybe_unused]] void* window,
+                               [[maybe_unused]] Component* comp,
+                               [[maybe_unused]] bool isNSView)
 {
-    ignoreUnused (window, comp, isNSView);
-
    #if ! JUCE_64BIT
     if (! isNSView)
         comp->setVisible ([((NSWindow*) window) isVisible]);
@@ -288,7 +284,7 @@ void checkWindowVisibilityVST (void* window, Component* comp, bool isNSView)
 }
 
 JUCE_API bool forwardCurrentKeyEventToHostVST (Component* comp, bool isNSView);
-bool forwardCurrentKeyEventToHostVST (Component* comp, bool isNSView)
+bool forwardCurrentKeyEventToHostVST ([[maybe_unused]] Component* comp, [[maybe_unused]] bool isNSView)
 {
    #if ! JUCE_64BIT
     if (! isNSView)
@@ -300,7 +296,6 @@ bool forwardCurrentKeyEventToHostVST (Component* comp, bool isNSView)
     }
    #endif
 
-    ignoreUnused (comp, isNSView);
     return false;
 }
 

modules/juce_audio_plugin_client/VST3/juce_VST3_Wrapper.cpp

@@ -1075,14 +1075,15 @@ public:
     }
 
     //==============================================================================
-    tresult PLUGIN_API getMidiControllerAssignment (Steinberg::int32 /*busIndex*/, Steinberg::int16 channel,
+    tresult PLUGIN_API getMidiControllerAssignment ([[maybe_unused]] Steinberg::int32 busIndex,
-                                                    Vst::CtrlNumber midiControllerNumber, Vst::ParamID& resultID) override
+                                                    [[maybe_unused]] Steinberg::int16 channel,
+                                                    [[maybe_unused]] Vst::CtrlNumber midiControllerNumber,
+                                                    [[maybe_unused]] Vst::ParamID& resultID) override
     {
        #if JUCE_VST3_EMULATE_MIDI_CC_WITH_PARAMETERS
         resultID = midiControllerToParameter[channel][midiControllerNumber];
         return kResultTrue; // Returning false makes some hosts stop asking for further MIDI Controller Assignments
        #else
-        ignoreUnused (channel, midiControllerNumber, resultID);
         return kResultFalse;
        #endif
     }
@@ -1991,7 +1992,7 @@ private:
             return kResultFalse;
         }
 
-        tresult PLUGIN_API setContentScaleFactor (const Steinberg::IPlugViewContentScaleSupport::ScaleFactor factor) override
+        tresult PLUGIN_API setContentScaleFactor ([[maybe_unused]] const Steinberg::IPlugViewContentScaleSupport::ScaleFactor factor) override
         {
            #if ! JUCE_MAC
             const auto scaleToApply = [&]
@@ -2016,7 +2017,6 @@ private:
 
             return kResultTrue;
            #else
-            ignoreUnused (factor);
             return kResultFalse;
            #endif
         }
@@ -2427,9 +2427,8 @@ public:
 
        #ifdef JucePlugin_PreferredChannelConfigurations
         short configs[][2] = { JucePlugin_PreferredChannelConfigurations };
-        const int numConfigs = numElementsInArray (configs);
+        [[maybe_unused]] const int numConfigs = numElementsInArray (configs);
 
-        ignoreUnused (numConfigs);
         jassert (numConfigs > 0 && (configs[0][0] > 0 || configs[0][1] > 0));
 
         pluginInstance->setPlayConfigDetails (configs[0][0], configs[0][1], 44100.0, 1024);

modules/juce_audio_plugin_client/utility/juce_PluginUtilities.cpp

@@ -134,7 +134,10 @@ namespace juce
 
 #if JucePlugin_Build_VST
  bool JUCE_API handleManufacturerSpecificVST2Opcode (int32 index, pointer_sized_int value, void* ptr, float);
- bool JUCE_API handleManufacturerSpecificVST2Opcode (int32 index, pointer_sized_int value, void* ptr, float)
+ bool JUCE_API handleManufacturerSpecificVST2Opcode ([[maybe_unused]] int32 index,
+                                                     [[maybe_unused]] pointer_sized_int value,
+                                                     [[maybe_unused]] void* ptr,
+                                                     float)
  {
     #if VST3_REPLACEMENT_AVAILABLE
      if ((index == (int32) ByteOrder::bigEndianInt ("stCA") || index == (int32) ByteOrder::bigEndianInt ("stCa"))
@@ -145,8 +148,6 @@ namespace juce
          ::memcpy (ptr, fuid, 16);
          return true;
      }
-    #else
-     ignoreUnused (index, value, ptr);
     #endif
      return false;
  }

modules/juce_audio_processors/format/juce_AudioPluginFormatManager.cpp

@@ -64,10 +64,8 @@ void AudioPluginFormatManager::addDefaultFormats()
 
    #if JUCE_DEBUG
     // you should only call this method once!
-    for (auto* format : formats)
+    for (auto* format [[maybe_unused]] : formats)
     {
-        ignoreUnused (format);
-
        #if HAS_VST
         jassert (dynamic_cast<VSTPluginFormat*> (format) == nullptr);
        #endif

modules/juce_audio_processors/format_types/juce_AudioUnitPluginFormat.mm

@@ -179,14 +179,15 @@ namespace AudioUnitFormatHelpers
         return false;
     }
 
-    static bool getComponentDescFromFile (const String& fileOrIdentifier, AudioComponentDescription& desc,
+    static bool getComponentDescFromFile ([[maybe_unused]] const String& fileOrIdentifier,
-                                          String& name, String& version, String& manufacturer)
+                                          [[maybe_unused]] AudioComponentDescription& desc,
+                                          [[maybe_unused]] String& name,
+                                          [[maybe_unused]] String& version,
+                                          [[maybe_unused]] String& manufacturer)
     {
         zerostruct (desc);
 
        #if JUCE_IOS
-        ignoreUnused (fileOrIdentifier, name, version, manufacturer);
-
         return false;
        #else
         const File file (fileOrIdentifier);
@@ -434,7 +435,7 @@ namespace AudioUnitFormatHelpers
     }
 }
 
-static bool hasARAExtension (AudioUnit audioUnit)
+static bool hasARAExtension ([[maybe_unused]] AudioUnit audioUnit)
 {
    #if JUCE_PLUGINHOST_ARA
     UInt32 propertySize = sizeof (ARA::ARAAudioUnitFactory);
@@ -449,8 +450,6 @@ static bool hasARAExtension (AudioUnit audioUnit)
 
     if ((status == noErr) && (propertySize == sizeof (ARA::ARAAudioUnitFactory)) && ! isWriteable)
         return true;
-   #else
-    ignoreUnused (audioUnit);
    #endif
 
     return false;
@@ -465,7 +464,7 @@ using AudioUnitUniquePtr = std::unique_ptr<std::remove_pointer_t<AudioUnit>, Aud
 using AudioUnitSharedPtr = std::shared_ptr<std::remove_pointer_t<AudioUnit>>;
 using AudioUnitWeakPtr = std::weak_ptr<std::remove_pointer_t<AudioUnit>>;
 
-static std::shared_ptr<const ARA::ARAFactory> getARAFactory (AudioUnitSharedPtr audioUnit)
+static std::shared_ptr<const ARA::ARAFactory> getARAFactory ([[maybe_unused]] AudioUnitSharedPtr audioUnit)
 {
    #if JUCE_PLUGINHOST_ARA
     jassert (audioUnit != nullptr);
@@ -491,8 +490,6 @@ static std::shared_ptr<const ARA::ARAFactory> getARAFactory (AudioUnitSharedPtr
                                           [owningAuPtr = std::move (audioUnit)]() {});
         }
     }
-   #else
-    ignoreUnused (audioUnit);
    #endif
 
     return {};
@@ -2640,13 +2637,12 @@ public:
         }
     }
 
-    void embedViewController (JUCE_IOS_MAC_VIEW* pluginView, const CGSize& size)
+    void embedViewController (JUCE_IOS_MAC_VIEW* pluginView, [[maybe_unused]] const CGSize& size)
     {
         wrapper.setView (pluginView);
         waitingForViewCallback = false;
 
       #if JUCE_MAC
-        ignoreUnused (size);
         if (pluginView != nil)
             wrapper.resizeToFitView();
       #else
@@ -2682,7 +2678,7 @@ private:
 
     bool waitingForViewCallback = false;
 
-    bool createView (bool createGenericViewIfNeeded)
+    bool createView ([[maybe_unused]] bool createGenericViewIfNeeded)
     {
         JUCE_IOS_MAC_VIEW* pluginView = nil;
         UInt32 dataSize = 0;
@@ -2756,8 +2752,6 @@ private:
 
             pluginView = [[AUGenericView alloc] initWithAudioUnit: plugin.audioUnit];
         }
-       #else
-        ignoreUnused (createGenericViewIfNeeded);
        #endif
 
         wrapper.setView (pluginView);

modules/juce_audio_processors/format_types/juce_LADSPAPluginFormat.cpp

@@ -384,10 +384,8 @@ public:
     void getCurrentProgramStateInformation (MemoryBlock& destData) override               { getStateInformation (destData); }
     void setCurrentProgramStateInformation (const void* data, int sizeInBytes) override   { setStateInformation (data, sizeInBytes); }
 
-    void setStateInformation (const void* data, int sizeInBytes) override
+    void setStateInformation (const void* data, [[maybe_unused]] int sizeInBytes) override
     {
-        ignoreUnused (sizeInBytes);
-
         auto* p = static_cast<const float*> (data);
 
         for (int i = 0; i < getParameters().size(); ++i)

modules/juce_audio_processors/format_types/juce_LV2PluginFormat.cpp

@@ -1278,10 +1278,8 @@ private:
                                                   LV2_Options_Option* options,
                                                   LV2_Worker_Schedule* schedule,
                                                   LV2_Resize_Port_Resize* resize,
-                                                  LV2_Log_Log* log)
+                                                  [[maybe_unused]] LV2_Log_Log* log)
     {
-        ignoreUnused (log);
-
         return { LV2_Feature { LV2_STATE__loadDefaultState,         nullptr },
                  LV2_Feature { LV2_BUF_SIZE__boundedBlockLength,    nullptr },
                  LV2_Feature { LV2_URID__map,                       map },
@@ -2873,11 +2871,10 @@ private:
 
         ports.forEachPort ([&] (const PortHeader& header)
         {
-            const auto emplaced = result.emplace (header.symbol, header.index);
+            [[maybe_unused]] const auto emplaced = result.emplace (header.symbol, header.index);
 
             // This will complain if there are duplicate port symbols.
             jassert (emplaced.second);
-            ignoreUnused (emplaced);
         });
 
         return result;
@@ -4884,10 +4881,8 @@ private:
                                                              : freeWheelingPort->info.min;
     }
 
-    void pushMessage (MessageHeader header, uint32_t size, const void* data)
+    void pushMessage (MessageHeader header, [[maybe_unused]] uint32_t size, const void* data)
     {
-        ignoreUnused (size);
-
         if (header.protocol == 0 || header.protocol == instance->urids.mLV2_UI__floatProtocol)
         {
             const auto value = readUnaligned<float> (data);

modules/juce_audio_processors/format_types/juce_VST3PluginFormat.cpp

@@ -375,9 +375,8 @@ struct VST3HostContext  : public Vst::IComponentHandler,  // From VST V3.0.0
     tresult PLUGIN_API setDirty (TBool) override;
 
     //==============================================================================
-    tresult PLUGIN_API requestOpenEditor (FIDString name) override
+    tresult PLUGIN_API requestOpenEditor ([[maybe_unused]] FIDString name) override
     {
-        ignoreUnused (name);
         jassertfalse;
         return kResultFalse;
     }
@@ -1388,7 +1387,7 @@ static int compareWithString (Type (&charArray)[N], const String& str)
 }
 
 template <typename Callback>
-static void forEachARAFactory (IPluginFactory* pluginFactory, Callback&& cb)
+static void forEachARAFactory ([[maybe_unused]] IPluginFactory* pluginFactory, [[maybe_unused]] Callback&& cb)
 {
    #if JUCE_PLUGINHOST_ARA && (JUCE_MAC || JUCE_WINDOWS || JUCE_LINUX)
     const auto numClasses = pluginFactory->countClasses();
@@ -1404,12 +1403,11 @@ static void forEachARAFactory (IPluginFactory* pluginFactory, Callback&& cb)
                 break;
         }
     }
-   #else
-    ignoreUnused (pluginFactory, cb);
    #endif
 }
 
-static std::shared_ptr<const ARA::ARAFactory> getARAFactory (Steinberg::IPluginFactory* pluginFactory, const String& pluginName)
+static std::shared_ptr<const ARA::ARAFactory> getARAFactory ([[maybe_unused]] Steinberg::IPluginFactory* pluginFactory,
+                                                             [[maybe_unused]] const String& pluginName)
 {
     std::shared_ptr<const ARA::ARAFactory> factory;
 
@@ -1432,8 +1430,6 @@ static std::shared_ptr<const ARA::ARAFactory> getARAFactory (Steinberg::IPluginF
 
                            return true;
                        });
-   #else
-    ignoreUnused (pluginFactory, pluginName);
    #endif
 
     return factory;
@@ -1667,8 +1663,8 @@ private:
                 return;
             }
 
-            const auto attachedResult = view->attached ((void*) pluginHandle, defaultVST3WindowType);
+            [[maybe_unused]] const auto attachedResult = view->attached ((void*) pluginHandle, defaultVST3WindowType);
-            ignoreUnused (warnOnFailure (attachedResult));
+            [[maybe_unused]] const auto warning = warnOnFailure (attachedResult);
 
             if (attachedResult == kResultOk)
                 attachedCalled = true;
@@ -1689,11 +1685,10 @@ private:
     {
         if (scaleInterface != nullptr)
         {
-            const auto result = scaleInterface->setContentScaleFactor ((Steinberg::IPlugViewContentScaleSupport::ScaleFactor) getEffectiveScale());
+            [[maybe_unused]] const auto result = scaleInterface->setContentScaleFactor ((Steinberg::IPlugViewContentScaleSupport::ScaleFactor) getEffectiveScale());
-            ignoreUnused (result);
 
            #if ! JUCE_MAC
-            ignoreUnused (warnOnFailure (result));
+            [[maybe_unused]] const auto warning = warnOnFailure (result);
            #endif
         }
     }
@@ -1885,8 +1880,7 @@ struct VST3ComponentHolder
         if (classIdx >= 0)
         {
             PClassInfo info;
-            bool success = (factory->getClassInfo (classIdx, &info) == kResultOk);
+            [[maybe_unused]] bool success = (factory->getClassInfo (classIdx, &info) == kResultOk);
-            ignoreUnused (success);
             jassert (success);
 
             VSTComSmartPtr<IPluginFactory2> pf2;
@@ -3091,9 +3085,9 @@ public:
     }
 
     /** @note Not applicable to VST3 */
-    void setCurrentProgramStateInformation (const void* data, int sizeInBytes) override
+    void setCurrentProgramStateInformation ([[maybe_unused]] const void* data,
+                                            [[maybe_unused]] int sizeInBytes) override
     {
-        ignoreUnused (data, sizeInBytes);
     }
 
 private:

modules/juce_audio_processors/format_types/juce_VSTPluginFormat.cpp

@@ -3028,10 +3028,8 @@ public:
     }
 
     //==============================================================================
-    void mouseDown (const MouseEvent& e) override
+    void mouseDown ([[maybe_unused]] const MouseEvent& e) override
     {
-        ignoreUnused (e);
-
        #if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD
         toFront (true);
        #endif

modules/juce_audio_processors/juce_audio_processors.cpp

@@ -220,6 +220,7 @@ private:
 #include "utilities/juce_AudioProcessorValueTreeState.cpp"
 #include "utilities/juce_PluginHostType.cpp"
 #include "utilities/juce_NativeScaleFactorNotifier.cpp"
+#include "utilities/juce_VSTCallbackHandler.cpp"
 #include "utilities/ARA/juce_ARA_utils.cpp"
 
 #include "format_types/juce_LV2PluginFormat.cpp"

modules/juce_audio_processors/processors/juce_AudioProcessor.cpp

@@ -340,7 +340,7 @@ void AudioProcessor::removeListener (AudioProcessorListener* listenerToRemove)
 
 void AudioProcessor::setPlayConfigDetails (int newNumIns, int newNumOuts, double newSampleRate, int newBlockSize)
 {
-    bool success = true;
+    [[maybe_unused]] bool success = true;
 
     if (getTotalNumInputChannels() != newNumIns)
         success &= setChannelLayoutOfBus (true,  0, AudioChannelSet::canonicalChannelSet (newNumIns));
@@ -362,7 +362,6 @@ void AudioProcessor::setPlayConfigDetails (int newNumIns, int newNumOuts, double
     jassert (success && newNumIns == getTotalNumInputChannels() && newNumOuts == getTotalNumOutputChannels());
 
     setRateAndBufferSizeDetails (newSampleRate, newBlockSize);
-    ignoreUnused (success);
 }
 
 void AudioProcessor::setRateAndBufferSizeDetails (double newSampleRate, int newBlockSize) noexcept
@@ -442,10 +441,8 @@ void AudioProcessor::validateParameter (AudioProcessorParameter* param)
    #endif
 }
 
-void AudioProcessor::checkForDuplicateTrimmedParamID (AudioProcessorParameter* param)
+void AudioProcessor::checkForDuplicateTrimmedParamID ([[maybe_unused]] AudioProcessorParameter* param)
 {
-    ignoreUnused (param);
-
    #if JUCE_DEBUG && ! JUCE_DISABLE_CAUTIOUS_PARAMETER_ID_CHECKING
     if (auto* withID = dynamic_cast<AudioProcessorParameterWithID*> (param))
     {
@@ -476,10 +473,8 @@ void AudioProcessor::checkForDuplicateTrimmedParamID (AudioProcessorParameter* p
    #endif
 }
 
-void AudioProcessor::checkForDuplicateParamID (AudioProcessorParameter* param)
+void AudioProcessor::checkForDuplicateParamID ([[maybe_unused]] AudioProcessorParameter* param)
 {
-    ignoreUnused (param);
-
    #if JUCE_DEBUG
     if (auto* withID = dynamic_cast<AudioProcessorParameterWithID*> (param))
     {
@@ -491,10 +486,8 @@ void AudioProcessor::checkForDuplicateParamID (AudioProcessorParameter* param)
    #endif
 }
 
-void AudioProcessor::checkForDuplicateGroupIDs (const AudioProcessorParameterGroup& newGroup)
+void AudioProcessor::checkForDuplicateGroupIDs ([[maybe_unused]] const AudioProcessorParameterGroup& newGroup)
 {
-    ignoreUnused (newGroup);
-
    #if JUCE_DEBUG
     auto groups = newGroup.getSubgroups (true);
     groups.add (&newGroup);
@@ -598,10 +591,9 @@ void AudioProcessor::processBypassed (AudioBuffer<floatType>& buffer, MidiBuffer
 void AudioProcessor::processBlockBypassed (AudioBuffer<float>&  buffer, MidiBuffer& midi)    { processBypassed (buffer, midi); }
 void AudioProcessor::processBlockBypassed (AudioBuffer<double>& buffer, MidiBuffer& midi)    { processBypassed (buffer, midi); }
 
-void AudioProcessor::processBlock (AudioBuffer<double>& buffer, MidiBuffer& midiMessages)
+void AudioProcessor::processBlock ([[maybe_unused]] AudioBuffer<double>& buffer,
+                                   [[maybe_unused]] MidiBuffer& midiMessages)
 {
-    ignoreUnused (buffer, midiMessages);
-
     // If you hit this assertion then either the caller called the double
     // precision version of processBlock on a processor which does not support it
     // (i.e. supportsDoublePrecisionProcessing() returns false), or the implementation
@@ -1493,6 +1485,9 @@ AudioProcessorParameter* AudioProcessor::getParamChecked (int index) const
     return p;
 }
 
+bool AudioProcessor::canAddBus ([[maybe_unused]] bool isInput) const                     { return false; }
+bool AudioProcessor::canRemoveBus ([[maybe_unused]] bool isInput) const                  { return false; }
+
 JUCE_END_IGNORE_WARNINGS_GCC_LIKE
 JUCE_END_IGNORE_WARNINGS_MSVC
 

modules/juce_audio_processors/processors/juce_AudioProcessor.h

@@ -524,7 +524,7 @@ public:
 
          @see addBus
     */
-    virtual bool canAddBus (bool isInput) const                     { ignoreUnused (isInput); return false; }
+    virtual bool canAddBus (bool isInput) const;
 
     /**  Callback to query if the last bus can currently be removed.
 
@@ -537,7 +537,7 @@ public:
 
          The default implementation will always return false.
     */
-    virtual bool canRemoveBus (bool isInput) const                  { ignoreUnused (isInput); return false; }
+    virtual bool canRemoveBus (bool isInput) const;
 
     /** Dynamically request an additional bus.
 

modules/juce_audio_processors/processors/juce_AudioProcessorEditor.cpp

@@ -216,13 +216,11 @@ void AudioProcessorEditor::setScaleFactor (float newScale)
 typedef ComponentPeer* (*createUnityPeerFunctionType) (Component&);
 createUnityPeerFunctionType juce_createUnityPeerFn = nullptr;
 
-ComponentPeer* AudioProcessorEditor::createNewPeer (int styleFlags, void* nativeWindow)
+ComponentPeer* AudioProcessorEditor::createNewPeer ([[maybe_unused]] int styleFlags,
+                                                    [[maybe_unused]] void* nativeWindow)
 {
     if (juce_createUnityPeerFn != nullptr)
-    {
-        ignoreUnused (styleFlags, nativeWindow);
         return juce_createUnityPeerFn (*this);
-    }
 
     return Component::createNewPeer (styleFlags, nativeWindow);
 }

modules/juce_audio_processors/utilities/ARA/juce_ARADocumentController.cpp

@@ -834,138 +834,122 @@ ARAEditorView* ARADocumentControllerSpecialisation::doCreateEditorView()
     return new ARAEditorView (getDocumentController());
 }
 
-bool ARADocumentControllerSpecialisation::doIsAudioSourceContentAvailable (const ARA::PlugIn::AudioSource* audioSource,
+bool ARADocumentControllerSpecialisation::doIsAudioSourceContentAvailable ([[maybe_unused]] const ARA::PlugIn::AudioSource* audioSource,
-                                                                           ARA::ARAContentType type)
+                                                                           [[maybe_unused]] ARA::ARAContentType type)
 {
-    juce::ignoreUnused (audioSource, type);
     return false;
 }
 
-ARA::ARAContentGrade ARADocumentControllerSpecialisation::doGetAudioSourceContentGrade (const ARA::PlugIn::AudioSource* audioSource,
+ARA::ARAContentGrade ARADocumentControllerSpecialisation::doGetAudioSourceContentGrade ([[maybe_unused]] const ARA::PlugIn::AudioSource* audioSource,
-                                                                                        ARA::ARAContentType type)
+                                                                                        [[maybe_unused]] ARA::ARAContentType type)
 {
     // Overriding doIsAudioSourceContentAvailable() requires overriding
     // doGetAudioSourceContentGrade() accordingly!
     jassertfalse;
 
-    juce::ignoreUnused (audioSource, type);
     return ARA::kARAContentGradeInitial;
 }
 
-ARA::PlugIn::ContentReader* ARADocumentControllerSpecialisation::doCreateAudioSourceContentReader (ARA::PlugIn::AudioSource* audioSource,
+ARA::PlugIn::ContentReader* ARADocumentControllerSpecialisation::doCreateAudioSourceContentReader ([[maybe_unused]] ARA::PlugIn::AudioSource* audioSource,
-                                                                                                   ARA::ARAContentType type,
+                                                                                                   [[maybe_unused]] ARA::ARAContentType type,
-                                                                                                   const ARA::ARAContentTimeRange* range)
+                                                                                                   [[maybe_unused]] const ARA::ARAContentTimeRange* range)
 {
     // Overriding doIsAudioSourceContentAvailable() requires overriding
     // doCreateAudioSourceContentReader() accordingly!
     jassertfalse;
 
-    juce::ignoreUnused (audioSource, type, range);
     return nullptr;
 }
 
-bool ARADocumentControllerSpecialisation::doIsAudioModificationContentAvailable (const ARA::PlugIn::AudioModification* audioModification,
+bool ARADocumentControllerSpecialisation::doIsAudioModificationContentAvailable ([[maybe_unused]] const ARA::PlugIn::AudioModification* audioModification,
-                                                                                 ARA::ARAContentType type)
+                                                                                 [[maybe_unused]] ARA::ARAContentType type)
 {
-    juce::ignoreUnused (audioModification, type);
     return false;
 }
 
-ARA::ARAContentGrade ARADocumentControllerSpecialisation::doGetAudioModificationContentGrade (const ARA::PlugIn::AudioModification* audioModification,
+ARA::ARAContentGrade ARADocumentControllerSpecialisation::doGetAudioModificationContentGrade ([[maybe_unused]] const ARA::PlugIn::AudioModification* audioModification,
-                                                                                              ARA::ARAContentType type)
+                                                                                              [[maybe_unused]] ARA::ARAContentType type)
 {
     // Overriding doIsAudioModificationContentAvailable() requires overriding
     // doGetAudioModificationContentGrade() accordingly!
     jassertfalse;
 
-    juce::ignoreUnused (audioModification, type);
     return ARA::kARAContentGradeInitial;
 }
 
-ARA::PlugIn::ContentReader* ARADocumentControllerSpecialisation::doCreateAudioModificationContentReader (ARA::PlugIn::AudioModification* audioModification,
+ARA::PlugIn::ContentReader* ARADocumentControllerSpecialisation::doCreateAudioModificationContentReader ([[maybe_unused]] ARA::PlugIn::AudioModification* audioModification,
-                                                                                                         ARA::ARAContentType type,
+                                                                                                         [[maybe_unused]] ARA::ARAContentType type,
-                                                                                                         const ARA::ARAContentTimeRange* range)
+                                                                                                         [[maybe_unused]] const ARA::ARAContentTimeRange* range)
 {
     // Overriding doIsAudioModificationContentAvailable() requires overriding
     // doCreateAudioModificationContentReader() accordingly!
     jassertfalse;
 
-    juce::ignoreUnused (audioModification, type, range);
     return nullptr;
 }
 
-bool ARADocumentControllerSpecialisation::doIsPlaybackRegionContentAvailable (const ARA::PlugIn::PlaybackRegion* playbackRegion,
+bool ARADocumentControllerSpecialisation::doIsPlaybackRegionContentAvailable ([[maybe_unused]] const ARA::PlugIn::PlaybackRegion* playbackRegion,
-                                                                              ARA::ARAContentType type)
+                                                                              [[maybe_unused]] ARA::ARAContentType type)
 {
-    juce::ignoreUnused (playbackRegion, type);
     return false;
 }
 
-ARA::ARAContentGrade ARADocumentControllerSpecialisation::doGetPlaybackRegionContentGrade (const ARA::PlugIn::PlaybackRegion* playbackRegion,
+ARA::ARAContentGrade ARADocumentControllerSpecialisation::doGetPlaybackRegionContentGrade ([[maybe_unused]] const ARA::PlugIn::PlaybackRegion* playbackRegion,
-                                                                                           ARA::ARAContentType type)
+                                                                                           [[maybe_unused]] ARA::ARAContentType type)
 {
     // Overriding doIsPlaybackRegionContentAvailable() requires overriding
     // doGetPlaybackRegionContentGrade() accordingly!
     jassertfalse;
 
-    juce::ignoreUnused (playbackRegion, type);
     return ARA::kARAContentGradeInitial;
 }
 
-ARA::PlugIn::ContentReader* ARADocumentControllerSpecialisation::doCreatePlaybackRegionContentReader (ARA::PlugIn::PlaybackRegion* playbackRegion,
+ARA::PlugIn::ContentReader* ARADocumentControllerSpecialisation::doCreatePlaybackRegionContentReader ([[maybe_unused]] ARA::PlugIn::PlaybackRegion* playbackRegion,
-                                                                                                      ARA::ARAContentType type,
+                                                                                                      [[maybe_unused]] ARA::ARAContentType type,
-                                                                                                      const ARA::ARAContentTimeRange* range)
+                                                                                                      [[maybe_unused]] const ARA::ARAContentTimeRange* range)
 {
     // Overriding doIsPlaybackRegionContentAvailable() requires overriding
     // doCreatePlaybackRegionContentReader() accordingly!
     jassertfalse;
 
-    juce::ignoreUnused (playbackRegion, type, range);
     return nullptr;
 }
 
-bool ARADocumentControllerSpecialisation::doIsAudioSourceContentAnalysisIncomplete (const ARA::PlugIn::AudioSource* audioSource,
+bool ARADocumentControllerSpecialisation::doIsAudioSourceContentAnalysisIncomplete ([[maybe_unused]] const ARA::PlugIn::AudioSource* audioSource,
-                                                                                    ARA::ARAContentType type)
+                                                                                    [[maybe_unused]] ARA::ARAContentType type)
 {
-    juce::ignoreUnused (audioSource, type);
     return false;
 }
 
-void ARADocumentControllerSpecialisation::doRequestAudioSourceContentAnalysis (ARA::PlugIn::AudioSource* audioSource,
+void ARADocumentControllerSpecialisation::doRequestAudioSourceContentAnalysis ([[maybe_unused]] ARA::PlugIn::AudioSource* audioSource,
-                                                                               std::vector<ARA::ARAContentType> const& contentTypes)
+                                                                               [[maybe_unused]] std::vector<ARA::ARAContentType> const& contentTypes)
 {
-    juce::ignoreUnused (audioSource, contentTypes);
 }
 
 ARA::ARAInt32 ARADocumentControllerSpecialisation::doGetProcessingAlgorithmsCount() { return 0; }
 
 const ARA::ARAProcessingAlgorithmProperties*
-    ARADocumentControllerSpecialisation::doGetProcessingAlgorithmProperties (ARA::ARAInt32 algorithmIndex)
+    ARADocumentControllerSpecialisation::doGetProcessingAlgorithmProperties ([[maybe_unused]] ARA::ARAInt32 algorithmIndex)
 {
-    juce::ignoreUnused (algorithmIndex);
     return nullptr;
 }
 
-ARA::ARAInt32 ARADocumentControllerSpecialisation::doGetProcessingAlgorithmForAudioSource (const ARA::PlugIn::AudioSource* audioSource)
+ARA::ARAInt32 ARADocumentControllerSpecialisation::doGetProcessingAlgorithmForAudioSource ([[maybe_unused]] const ARA::PlugIn::AudioSource* audioSource)
 {
     // doGetProcessingAlgorithmForAudioSource() must be implemented if the supported
     // algorithm count is greater than zero.
     if (getDocumentController()->getProcessingAlgorithmsCount() > 0)
         jassertfalse;
 
-    juce::ignoreUnused (audioSource);
     return 0;
 }
 
-void ARADocumentControllerSpecialisation::doRequestProcessingAlgorithmForAudioSource (ARA::PlugIn::AudioSource* audioSource,
+void ARADocumentControllerSpecialisation::doRequestProcessingAlgorithmForAudioSource ([[maybe_unused]] ARA::PlugIn::AudioSource* audioSource,
-                                                                                      ARA::ARAInt32 algorithmIndex)
+                                                                                      [[maybe_unused]] ARA::ARAInt32 algorithmIndex)
 {
     // doRequestProcessingAlgorithmForAudioSource() must be implemented if the supported
     // algorithm count is greater than zero.
-    if (getDocumentController()->getProcessingAlgorithmsCount() > 0)
+    jassert (getDocumentController()->getProcessingAlgorithmsCount() <= 0);
-        jassertfalse;
-
-    juce::ignoreUnused (audioSource, algorithmIndex);
 }
 
 } // namespace juce

modules/juce_audio_processors/utilities/ARA/juce_ARAModelObjects.cpp

@@ -196,4 +196,98 @@ void ARAPlaybackRegion::notifyContentChanged (ARAContentUpdateScopes scopeFlags,
                                                                                                 notifyARAHost);
 }
 
+//==============================================================================
+void ARADocumentListener::willBeginEditing ([[maybe_unused]] ARADocument* document) {}
+void ARADocumentListener::didEndEditing ([[maybe_unused]] ARADocument* document) {}
+void ARADocumentListener::willNotifyModelUpdates ([[maybe_unused]] ARADocument* document) {}
+void ARADocumentListener::didNotifyModelUpdates ([[maybe_unused]] ARADocument* document) {}
+void ARADocumentListener::willUpdateDocumentProperties ([[maybe_unused]] ARADocument* document,
+                                                        [[maybe_unused]] ARA::PlugIn::PropertiesPtr<ARA::ARADocumentProperties> newProperties) {}
+void ARADocumentListener::didUpdateDocumentProperties ([[maybe_unused]] ARADocument* document) {}
+void ARADocumentListener::didAddMusicalContextToDocument ([[maybe_unused]] ARADocument* document,
+                                                          [[maybe_unused]] ARAMusicalContext* musicalContext) {}
+void ARADocumentListener::willRemoveMusicalContextFromDocument ([[maybe_unused]] ARADocument* document,
+                                                                [[maybe_unused]] ARAMusicalContext* musicalContext) {}
+void ARADocumentListener::didReorderMusicalContextsInDocument ([[maybe_unused]] ARADocument* document) {}
+void ARADocumentListener::didAddRegionSequenceToDocument ([[maybe_unused]] ARADocument* document,
+                                                          [[maybe_unused]] ARARegionSequence* regionSequence) {}
+void ARADocumentListener::willRemoveRegionSequenceFromDocument ([[maybe_unused]] ARADocument* document,
+                                                                [[maybe_unused]] ARARegionSequence* regionSequence) {}
+void ARADocumentListener::didReorderRegionSequencesInDocument ([[maybe_unused]] ARADocument* document) {}
+void ARADocumentListener::didAddAudioSourceToDocument ([[maybe_unused]] ARADocument* document,
+                                                       [[maybe_unused]] ARAAudioSource* audioSource) {}
+void ARADocumentListener::willRemoveAudioSourceFromDocument ([[maybe_unused]] ARADocument* document,
+                                                             [[maybe_unused]] ARAAudioSource* audioSource) {}
+void ARADocumentListener::willDestroyDocument ([[maybe_unused]] ARADocument* document) {}
+
+//==============================================================================
+void ARAMusicalContextListener::willUpdateMusicalContextProperties ([[maybe_unused]] ARAMusicalContext* musicalContext,
+                                                                    [[maybe_unused]] ARA::PlugIn::PropertiesPtr<ARA::ARAMusicalContextProperties> newProperties) {}
+void ARAMusicalContextListener::didUpdateMusicalContextProperties ([[maybe_unused]] ARAMusicalContext* musicalContext) {}
+void ARAMusicalContextListener::doUpdateMusicalContextContent ([[maybe_unused]] ARAMusicalContext* musicalContext,
+                                                               [[maybe_unused]] ARAContentUpdateScopes scopeFlags) {}
+void ARAMusicalContextListener::didAddRegionSequenceToMusicalContext ([[maybe_unused]] ARAMusicalContext* musicalContext,
+                                                                      [[maybe_unused]] ARARegionSequence* regionSequence) {}
+void ARAMusicalContextListener::willRemoveRegionSequenceFromMusicalContext ([[maybe_unused]] ARAMusicalContext* musicalContext,
+                                                                            [[maybe_unused]] ARARegionSequence* regionSequence) {}
+void ARAMusicalContextListener::didReorderRegionSequencesInMusicalContext ([[maybe_unused]] ARAMusicalContext* musicalContext) {}
+void ARAMusicalContextListener::willDestroyMusicalContext ([[maybe_unused]] ARAMusicalContext* musicalContext) {}
+
+//==============================================================================
+void ARAPlaybackRegionListener::willUpdatePlaybackRegionProperties ([[maybe_unused]] ARAPlaybackRegion* playbackRegion,
+                                                                    [[maybe_unused]] ARA::PlugIn::PropertiesPtr<ARA::ARAPlaybackRegionProperties> newProperties) {}
+void ARAPlaybackRegionListener::didUpdatePlaybackRegionProperties ([[maybe_unused]] ARAPlaybackRegion* playbackRegion) {}
+void ARAPlaybackRegionListener::didUpdatePlaybackRegionContent ([[maybe_unused]] ARAPlaybackRegion* playbackRegion,
+                                                                [[maybe_unused]] ARAContentUpdateScopes scopeFlags) {}
+void ARAPlaybackRegionListener::willDestroyPlaybackRegion ([[maybe_unused]] ARAPlaybackRegion* playbackRegion) {}
+
+//==============================================================================
+void ARARegionSequenceListener::willUpdateRegionSequenceProperties ([[maybe_unused]] ARARegionSequence* regionSequence,
+                                                                    [[maybe_unused]] ARA::PlugIn::PropertiesPtr<ARA::ARARegionSequenceProperties> newProperties) {}
+void ARARegionSequenceListener::didUpdateRegionSequenceProperties ([[maybe_unused]] ARARegionSequence* regionSequence) {}
+void ARARegionSequenceListener::willRemovePlaybackRegionFromRegionSequence ([[maybe_unused]] ARARegionSequence* regionSequence,
+                                                                            [[maybe_unused]] ARAPlaybackRegion* playbackRegion) {}
+void ARARegionSequenceListener::didAddPlaybackRegionToRegionSequence ([[maybe_unused]] ARARegionSequence* regionSequence,
+                                                                      [[maybe_unused]] ARAPlaybackRegion* playbackRegion) {}
+void ARARegionSequenceListener::willDestroyRegionSequence ([[maybe_unused]] ARARegionSequence* regionSequence) {}
+
+//==============================================================================
+void ARAAudioSourceListener::willUpdateAudioSourceProperties ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                              [[maybe_unused]] ARA::PlugIn::PropertiesPtr<ARA::ARAAudioSourceProperties> newProperties) {}
+void ARAAudioSourceListener::didUpdateAudioSourceProperties ([[maybe_unused]] ARAAudioSource* audioSource) {}
+void ARAAudioSourceListener::doUpdateAudioSourceContent ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                         [[maybe_unused]] ARAContentUpdateScopes scopeFlags) {}
+void ARAAudioSourceListener::didUpdateAudioSourceAnalysisProgress ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                                   [[maybe_unused]] ARA::ARAAnalysisProgressState state,
+                                                                   [[maybe_unused]] float progress) {}
+void ARAAudioSourceListener::willEnableAudioSourceSamplesAccess ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                                 [[maybe_unused]] bool enable) {}
+void ARAAudioSourceListener::didEnableAudioSourceSamplesAccess ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                                [[maybe_unused]] bool enable) {}
+void ARAAudioSourceListener::willDeactivateAudioSourceForUndoHistory ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                                      [[maybe_unused]] bool deactivate) {}
+void ARAAudioSourceListener::didDeactivateAudioSourceForUndoHistory ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                                     [[maybe_unused]] bool deactivate) {}
+void ARAAudioSourceListener::didAddAudioModificationToAudioSource ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                                   [[maybe_unused]] ARAAudioModification* audioModification) {}
+void ARAAudioSourceListener::willRemoveAudioModificationFromAudioSource ([[maybe_unused]] ARAAudioSource* audioSource,
+                                                                         [[maybe_unused]] ARAAudioModification* audioModification) {}
+void ARAAudioSourceListener::willDestroyAudioSource ([[maybe_unused]] ARAAudioSource* audioSource) {}
+
+//==============================================================================
+void ARAAudioModificationListener::willUpdateAudioModificationProperties ([[maybe_unused]] ARAAudioModification* audioModification,
+                                                                          [[maybe_unused]] ARA::PlugIn::PropertiesPtr<ARA::ARAAudioModificationProperties> newProperties) {}
+void ARAAudioModificationListener::didUpdateAudioModificationProperties ([[maybe_unused]] ARAAudioModification* audioModification) {}
+void ARAAudioModificationListener::didUpdateAudioModificationContent ([[maybe_unused]] ARAAudioModification* audioModification,
+                                                                      [[maybe_unused]] ARAContentUpdateScopes scopeFlags) {}
+void ARAAudioModificationListener::willDeactivateAudioModificationForUndoHistory ([[maybe_unused]] ARAAudioModification* audioModification,
+                                                                                  [[maybe_unused]] bool deactivate) {}
+void ARAAudioModificationListener::didDeactivateAudioModificationForUndoHistory ([[maybe_unused]] ARAAudioModification* audioModification,
+                                                                                 [[maybe_unused]] bool deactivate) {}
+void ARAAudioModificationListener::didAddPlaybackRegionToAudioModification ([[maybe_unused]] ARAAudioModification* audioModification,
+                                                                            [[maybe_unused]] ARAPlaybackRegion* playbackRegion) {}
+void ARAAudioModificationListener::willRemovePlaybackRegionFromAudioModification ([[maybe_unused]] ARAAudioModification* audioModification,
+                                                                                  [[maybe_unused]] ARAPlaybackRegion* playbackRegion) {}
+void ARAAudioModificationListener::willDestroyAudioModification ([[maybe_unused]] ARAAudioModification* audioModification) {}
+
 } // namespace juce

modules/juce_audio_processors/utilities/ARA/juce_ARAModelObjects.h

@@ -181,76 +181,49 @@ public:
     /** Destructor */
     virtual ~ARADocumentListener() = default;
 
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN
-
     /** Called before the document enters an editing state.
         @param document The document about to enter an editing state.
     */
-    virtual void willBeginEditing (ARADocument* document)
+    virtual void willBeginEditing (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
 
     /** Called after the document exits an editing state.
         @param document The document about exit an editing state.
     */
-    virtual void didEndEditing (ARADocument* document)
+    virtual void didEndEditing (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
 
     /** Called before sending model updates do the host.
         @param document The document whose model updates are about to be sent.
     */
-    virtual void willNotifyModelUpdates (ARADocument* document)
+    virtual void willNotifyModelUpdates (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
 
     /** Called after sending model updates do the host.
         @param document The document whose model updates have just been sent.
     */
-    virtual void didNotifyModelUpdates (ARADocument* document)
+    virtual void didNotifyModelUpdates (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
 
     /** Called before the document's properties are updated.
         @param document The document whose properties will be updated.
         @param newProperties The document properties that will be assigned to \p document.
     */
     virtual void willUpdateDocumentProperties (ARADocument* document,
-                                               ARA::PlugIn::PropertiesPtr<ARA::ARADocumentProperties> newProperties)
+                                               ARA::PlugIn::PropertiesPtr<ARA::ARADocumentProperties> newProperties);
-    {
-        ignoreUnused (document, newProperties);
-    }
 
     /** Called after the document's properties are updated.
         @param document The document whose properties were updated.
     */
-    virtual void didUpdateDocumentProperties (ARADocument* document)
+    virtual void didUpdateDocumentProperties (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
 
     /** Called after a musical context is added to the document.
         @param document The document that \p musicalContext was added to.
         @param musicalContext The musical context that was added to \p document.
     */
-    virtual void didAddMusicalContextToDocument (ARADocument* document, ARAMusicalContext* musicalContext)
+    virtual void didAddMusicalContextToDocument (ARADocument* document, ARAMusicalContext* musicalContext);
-    {
-        ignoreUnused (document, musicalContext);
-    }
 
     /** Called before a musical context is removed from the document.
         @param document The document that \p musicalContext will be removed from.
         @param musicalContext The musical context that will be removed from \p document.
     */
-    virtual void willRemoveMusicalContextFromDocument (ARADocument* document,
+    virtual void willRemoveMusicalContextFromDocument (ARADocument* document, ARAMusicalContext* musicalContext);
-                                                       ARAMusicalContext* musicalContext)
-    {
-        ignoreUnused (document, musicalContext);
-    }
 
     /** Called after the musical contexts are reordered in an ARA document
 
@@ -259,29 +232,19 @@ public:
 
         @param document The document with reordered musical contexts.
     */
-    virtual void didReorderMusicalContextsInDocument (ARADocument* document)
+    virtual void didReorderMusicalContextsInDocument (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
 
     /** Called after a region sequence is added to the document.
         @param document The document that \p regionSequence was added to.
         @param regionSequence The region sequence that was added to \p document.
     */
-    virtual void didAddRegionSequenceToDocument (ARADocument* document, ARARegionSequence* regionSequence)
+    virtual void didAddRegionSequenceToDocument (ARADocument* document, ARARegionSequence* regionSequence);
-    {
-        ignoreUnused (document, regionSequence);
-    }
 
     /** Called before a region sequence is removed from the document.
         @param document The document that \p regionSequence will be removed from.
         @param regionSequence The region sequence that will be removed from \p document.
     */
-    virtual void willRemoveRegionSequenceFromDocument (ARADocument* document,
+    virtual void willRemoveRegionSequenceFromDocument (ARADocument* document, ARARegionSequence* regionSequence);
-                                                       ARARegionSequence* regionSequence)
-    {
-        ignoreUnused (document, regionSequence);
-    }
 
     /** Called after the region sequences are reordered in an ARA document
 
@@ -290,38 +253,24 @@ public:
 
         @param document The document with reordered region sequences.
     */
-    virtual void didReorderRegionSequencesInDocument (ARADocument* document)
+    virtual void didReorderRegionSequencesInDocument (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
 
     /** Called after an audio source is added to the document.
         @param document The document that \p audioSource was added to.
         @param audioSource The audio source that was added to \p document.
     */
-    virtual void didAddAudioSourceToDocument (ARADocument* document, ARAAudioSource* audioSource)
+    virtual void didAddAudioSourceToDocument (ARADocument* document, ARAAudioSource* audioSource);
-    {
-        ignoreUnused (document, audioSource);
-    }
 
     /** Called before an audio source is removed from the document.
         @param document The document that \p audioSource will be removed from .
         @param audioSource The audio source that will be removed from \p document.
     */
-    virtual void willRemoveAudioSourceFromDocument (ARADocument* document, ARAAudioSource* audioSource)
+    virtual void willRemoveAudioSourceFromDocument (ARADocument* document, ARAAudioSource* audioSource);
-    {
-        ignoreUnused (document, audioSource);
-    }
 
     /** Called before the document is destroyed by the ARA host.
         @param document The document that will be destroyed.
     */
-    virtual void willDestroyDocument (ARADocument* document)
+    virtual void willDestroyDocument (ARADocument* document);
-    {
-        ignoreUnused (document);
-    }
-
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
 };
 
 //==============================================================================
@@ -395,55 +344,36 @@ class JUCE_API  ARAMusicalContextListener
 public:
     virtual ~ARAMusicalContextListener() = default;
 
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN
-
     /** Called before the musical context's properties are updated.
         @param musicalContext The musical context whose properties will be updated.
         @param newProperties The musical context properties that will be assigned to \p musicalContext.
     */
     virtual void willUpdateMusicalContextProperties (ARAMusicalContext* musicalContext,
-                                                     ARA::PlugIn::PropertiesPtr<ARA::ARAMusicalContextProperties> newProperties)
+                                                     ARA::PlugIn::PropertiesPtr<ARA::ARAMusicalContextProperties> newProperties);
-    {
-        ignoreUnused (musicalContext, newProperties);
-    }
 
     /** Called after the musical context's properties are updated by the host.
         @param musicalContext The musical context whose properties were updated.
     */
-    virtual void didUpdateMusicalContextProperties (ARAMusicalContext* musicalContext)
+    virtual void didUpdateMusicalContextProperties (ARAMusicalContext* musicalContext);
-    {
-        ignoreUnused (musicalContext);
-    }
 
     /** Called when the musical context's content (i.e tempo entries or chords) changes.
         @param musicalContext The musical context with updated content.
         @param scopeFlags The scope of the content update indicating what has changed.
     */
-    virtual void doUpdateMusicalContextContent (ARAMusicalContext* musicalContext,
+    virtual void doUpdateMusicalContextContent (ARAMusicalContext* musicalContext, ARAContentUpdateScopes scopeFlags);
-                                                ARAContentUpdateScopes scopeFlags)
-    {
-        ignoreUnused (musicalContext, scopeFlags);
-    }
 
     /** Called after a region sequence is added to the musical context.
         @param musicalContext The musical context that \p regionSequence was added to.
         @param regionSequence The region sequence that was added to \p musicalContext.
     */
-    virtual void didAddRegionSequenceToMusicalContext (ARAMusicalContext* musicalContext,
+    virtual void didAddRegionSequenceToMusicalContext (ARAMusicalContext* musicalContext, ARARegionSequence* regionSequence);
-                                                       ARARegionSequence* regionSequence)
-    {
-        ignoreUnused (musicalContext, regionSequence);
-    }
 
     /** Called before a region sequence is removed from the musical context.
         @param musicalContext The musical context that \p regionSequence will be removed from.
         @param regionSequence The region sequence that will be removed from \p musicalContext.
     */
     virtual void willRemoveRegionSequenceFromMusicalContext (ARAMusicalContext* musicalContext,
-                                                             ARARegionSequence* regionSequence)
+                                                             ARARegionSequence* regionSequence);
-    {
-        ignoreUnused (musicalContext, regionSequence);
-    }
 
     /** Called after the region sequences are reordered in an ARA MusicalContext
 
@@ -452,20 +382,12 @@ public:
 
         @param musicalContext The musical context with reordered region sequences.
     */
-    virtual void didReorderRegionSequencesInMusicalContext (ARAMusicalContext* musicalContext)
+    virtual void didReorderRegionSequencesInMusicalContext (ARAMusicalContext* musicalContext);
-    {
-        ignoreUnused (musicalContext);
-    }
 
     /** Called before the musical context is destroyed.
         @param musicalContext The musical context that will be destroyed.
     */
-    virtual void willDestroyMusicalContext (ARAMusicalContext* musicalContext)
+    virtual void willDestroyMusicalContext (ARAMusicalContext* musicalContext);
-    {
-        ignoreUnused (musicalContext);
-    }
-
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
 };
 
 //==============================================================================
@@ -528,45 +450,29 @@ public:
     /** Destructor. */
     virtual ~ARAPlaybackRegionListener() = default;
 
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN
-
     /** Called before the playback region's properties are updated.
         @param playbackRegion The playback region whose properties will be updated.
         @param newProperties The playback region properties that will be assigned to \p playbackRegion.
     */
     virtual void willUpdatePlaybackRegionProperties (ARAPlaybackRegion* playbackRegion,
-                                                     ARA::PlugIn::PropertiesPtr<ARA::ARAPlaybackRegionProperties> newProperties)
+                                                     ARA::PlugIn::PropertiesPtr<ARA::ARAPlaybackRegionProperties> newProperties);
-    {
-        ignoreUnused (playbackRegion, newProperties);
-    }
 
     /** Called after the playback region's properties are updated.
         @param playbackRegion The playback region whose properties were updated.
     */
-    virtual void didUpdatePlaybackRegionProperties (ARAPlaybackRegion* playbackRegion)
+    virtual void didUpdatePlaybackRegionProperties (ARAPlaybackRegion* playbackRegion);
-    {
-        ignoreUnused (playbackRegion);
-    }
 
     /** Called when the playback region's content (i.e. samples or notes) changes.
         @param playbackRegion The playback region with updated content.
         @param scopeFlags The scope of the content update.
     */
     virtual void didUpdatePlaybackRegionContent (ARAPlaybackRegion* playbackRegion,
-                                                 ARAContentUpdateScopes scopeFlags)
+                                                 ARAContentUpdateScopes scopeFlags);
-    {
-        ignoreUnused (playbackRegion, scopeFlags);
-    }
 
     /** Called before the playback region is destroyed.
         @param playbackRegion The playback region that will be destroyed.
     */
-    virtual void willDestroyPlaybackRegion (ARAPlaybackRegion* playbackRegion)
+    virtual void willDestroyPlaybackRegion (ARAPlaybackRegion* playbackRegion);
-    {
-        ignoreUnused (playbackRegion);
-    }
-
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
 };
 
 //==============================================================================
@@ -665,55 +571,36 @@ public:
     /** Destructor. */
     virtual ~ARARegionSequenceListener() = default;
 
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN
-
     /** Called before the region sequence's properties are updated.
         @param regionSequence The region sequence whose properties will be updated.
         @param newProperties The region sequence properties that will be assigned to \p regionSequence.
     */
     virtual void willUpdateRegionSequenceProperties (ARARegionSequence* regionSequence,
-                                                     ARA::PlugIn::PropertiesPtr<ARA::ARARegionSequenceProperties> newProperties)
+                                                     ARA::PlugIn::PropertiesPtr<ARA::ARARegionSequenceProperties> newProperties);
-    {
-        ignoreUnused (regionSequence, newProperties);
-    }
 
     /** Called after the region sequence's properties are updated.
         @param regionSequence The region sequence whose properties were updated.
     */
-    virtual void didUpdateRegionSequenceProperties (ARARegionSequence* regionSequence)
+    virtual void didUpdateRegionSequenceProperties (ARARegionSequence* regionSequence);
-    {
-        ignoreUnused (regionSequence);
-    }
 
     /** Called before a playback region is removed from the region sequence.
         @param regionSequence The region sequence that \p playbackRegion will be removed from.
         @param playbackRegion The playback region that will be removed from \p regionSequence.
     */
     virtual void willRemovePlaybackRegionFromRegionSequence (ARARegionSequence* regionSequence,
-                                                             ARAPlaybackRegion* playbackRegion)
+                                                             ARAPlaybackRegion* playbackRegion);
-    {
-        ignoreUnused (regionSequence, playbackRegion);
-    }
 
     /** Called after a playback region is added to the region sequence.
         @param regionSequence The region sequence that \p playbackRegion was added to.
         @param playbackRegion The playback region that was added to \p regionSequence.
     */
     virtual void didAddPlaybackRegionToRegionSequence (ARARegionSequence* regionSequence,
-                                                       ARAPlaybackRegion* playbackRegion)
+                                                       ARAPlaybackRegion* playbackRegion);
-    {
-        ignoreUnused (regionSequence, playbackRegion);
-    }
 
     /** Called before the region sequence is destroyed.
         @param regionSequence The region sequence that will be destroyed.
     */
-    virtual void willDestroyRegionSequence (ARARegionSequence* regionSequence)
+    virtual void willDestroyRegionSequence (ARARegionSequence* regionSequence);
-    {
-        ignoreUnused (regionSequence);
-    }
-
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
 };
 
 //==============================================================================
@@ -800,34 +687,23 @@ public:
     /** Destructor. */
     virtual ~ARAAudioSourceListener() = default;
 
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN
-
     /** Called before the audio source's properties are updated.
         @param audioSource The audio source whose properties will be updated.
         @param newProperties The audio source properties that will be assigned to \p audioSource.
     */
     virtual void willUpdateAudioSourceProperties (ARAAudioSource* audioSource,
-                                                  ARA::PlugIn::PropertiesPtr<ARA::ARAAudioSourceProperties> newProperties)
+                                                  ARA::PlugIn::PropertiesPtr<ARA::ARAAudioSourceProperties> newProperties);
-    {
-        ignoreUnused (audioSource, newProperties);
-    }
 
     /** Called after the audio source's properties are updated.
         @param audioSource The audio source whose properties were updated.
     */
-    virtual void didUpdateAudioSourceProperties (ARAAudioSource* audioSource)
+    virtual void didUpdateAudioSourceProperties (ARAAudioSource* audioSource);
-    {
-        ignoreUnused (audioSource);
-    }
 
     /** Called when the audio source's content (i.e. samples or notes) changes.
         @param audioSource The audio source with updated content.
         @param scopeFlags The scope of the content update.
     */
-    virtual void doUpdateAudioSourceContent (ARAAudioSource* audioSource, ARAContentUpdateScopes scopeFlags)
+    virtual void doUpdateAudioSourceContent (ARAAudioSource* audioSource, ARAContentUpdateScopes scopeFlags);
-    {
-        ignoreUnused (audioSource, scopeFlags);
-    }
 
     /** Called to notify progress when an audio source is being analyzed.
         @param audioSource The audio source being analyzed.
@@ -836,76 +712,54 @@ public:
     */
     virtual void didUpdateAudioSourceAnalysisProgress (ARAAudioSource* audioSource,
                                                        ARA::ARAAnalysisProgressState state,
-                                                       float progress)
+                                                       float progress);
-    {
-        ignoreUnused (audioSource, state, progress);
-    }
 
     /** Called before access to an audio source's samples is enabled or disabled.
         @param audioSource The audio source whose sample access state will be changed.
         @param enable A bool indicating whether or not sample access will be enabled or disabled.
     */
-    virtual void willEnableAudioSourceSamplesAccess (ARAAudioSource* audioSource, bool enable)
+    virtual void willEnableAudioSourceSamplesAccess (ARAAudioSource* audioSource,
-    {
+                                                     bool enable);
-        ignoreUnused (audioSource, enable);
-    }
 
     /** Called after access to an audio source's samples is enabled or disabled.
         @param audioSource The audio source whose sample access state was changed.
         @param enable A bool indicating whether or not sample access was enabled or disabled.
     */
-    virtual void didEnableAudioSourceSamplesAccess (ARAAudioSource* audioSource, bool enable)
+    virtual void didEnableAudioSourceSamplesAccess (ARAAudioSource* audioSource,
-    {
+                                                    bool enable);
-        ignoreUnused (audioSource, enable);
-    }
 
     /** Called before an audio source is activated or deactivated when being removed / added from the host's undo history.
         @param audioSource The audio source that will be activated or deactivated
         @param deactivate A bool indicating whether \p audioSource was deactivated or activated.
     */
-    virtual void willDeactivateAudioSourceForUndoHistory (ARAAudioSource* audioSource, bool deactivate)
+    virtual void willDeactivateAudioSourceForUndoHistory (ARAAudioSource* audioSource,
-    {
+                                                          bool deactivate);
-        ignoreUnused (audioSource, deactivate);
-    }
 
     /** Called after an audio source is activated or deactivated when being removed / added from the host's undo history.
         @param audioSource The audio source that was activated or deactivated
         @param deactivate A bool indicating whether \p audioSource was deactivated or activated.
     */
-    virtual void didDeactivateAudioSourceForUndoHistory (ARAAudioSource* audioSource, bool deactivate)
+    virtual void didDeactivateAudioSourceForUndoHistory (ARAAudioSource* audioSource,
-    {
+                                                         bool deactivate);
-        ignoreUnused (audioSource, deactivate);
-    }
 
     /** Called after an audio modification is added to the audio source.
         @param audioSource The region sequence that \p audioModification was added to.
         @param audioModification The playback region that was added to \p audioSource.
     */
     virtual void didAddAudioModificationToAudioSource (ARAAudioSource* audioSource,
-                                                       ARAAudioModification* audioModification)
+                                                       ARAAudioModification* audioModification);
-    {
-        ignoreUnused (audioSource, audioModification);
-    }
 
     /** Called before an audio modification is removed from the audio source.
         @param audioSource The audio source that \p audioModification will be removed from.
         @param audioModification The audio modification that will be removed from \p audioSource.
     */
     virtual void willRemoveAudioModificationFromAudioSource (ARAAudioSource* audioSource,
-                                                             ARAAudioModification* audioModification)
+                                                             ARAAudioModification* audioModification);
-    {
-        ignoreUnused (audioSource, audioModification);
-    }
 
     /** Called before the audio source is destroyed.
         @param audioSource The audio source that will be destroyed.
     */
-    virtual void willDestroyAudioSource (ARAAudioSource* audioSource)
+    virtual void willDestroyAudioSource (ARAAudioSource* audioSource);
-    {
-        ignoreUnused (audioSource);
-    }
-
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
 };
 
 //==============================================================================
@@ -1004,82 +858,57 @@ public:
     /** Destructor. */
     virtual ~ARAAudioModificationListener() = default;
 
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN
-
     /** Called before the audio modification's properties are updated.
         @param audioModification The audio modification whose properties will be updated.
         @param newProperties The audio modification properties that will be assigned to \p audioModification.
     */
     virtual void willUpdateAudioModificationProperties (ARAAudioModification* audioModification,
-                                                        ARA::PlugIn::PropertiesPtr<ARA::ARAAudioModificationProperties> newProperties)
+                                                        ARA::PlugIn::PropertiesPtr<ARA::ARAAudioModificationProperties> newProperties);
-    {
-        ignoreUnused (audioModification, newProperties);
-    }
 
     /** Called after the audio modification's properties are updated.
         @param audioModification The audio modification whose properties were updated.
     */
-    virtual void didUpdateAudioModificationProperties (ARAAudioModification* audioModification)
+    virtual void didUpdateAudioModificationProperties (ARAAudioModification* audioModification);
-    {
-        ignoreUnused (audioModification);
-    }
 
     /** Called when the audio modification's content (i.e. samples or notes) changes.
         @param audioModification The audio modification with updated content.
         @param scopeFlags The scope of the content update.
     */
-    virtual void didUpdateAudioModificationContent (ARAAudioModification* audioModification, ARAContentUpdateScopes scopeFlags)
+    virtual void didUpdateAudioModificationContent (ARAAudioModification* audioModification,
-    {
+                                                    ARAContentUpdateScopes scopeFlags);
-        ignoreUnused (audioModification, scopeFlags);
-    }
 
     /** Called before an audio modification is activated or deactivated when being removed / added from the host's undo history.
         @param audioModification The audio modification that was activated or deactivated
         @param deactivate A bool indicating whether \p audioModification was deactivated or activated.
     */
-    virtual void willDeactivateAudioModificationForUndoHistory (ARAAudioModification* audioModification, bool deactivate)
+    virtual void willDeactivateAudioModificationForUndoHistory (ARAAudioModification* audioModification,
-    {
+                                                                bool deactivate);
-        ignoreUnused (audioModification, deactivate);
-    }
 
     /** Called after an audio modification is activated or deactivated when being removed / added from the host's undo history.
         @param audioModification The audio modification that was activated or deactivated
         @param deactivate A bool indicating whether \p audioModification was deactivated or activated.
     */
-    virtual void didDeactivateAudioModificationForUndoHistory (ARAAudioModification* audioModification, bool deactivate)
+    virtual void didDeactivateAudioModificationForUndoHistory (ARAAudioModification* audioModification,
-    {
+                                                               bool deactivate);
-        ignoreUnused (audioModification, deactivate);
-    }
 
     /** Called after a playback region is added to the audio modification.
         @param audioModification The audio modification that \p playbackRegion was added to.
         @param playbackRegion The playback region that was added to \p audioModification.
     */
     virtual void didAddPlaybackRegionToAudioModification (ARAAudioModification* audioModification,
-                                                          ARAPlaybackRegion* playbackRegion)
+                                                          ARAPlaybackRegion* playbackRegion);
-    {
-        ignoreUnused (audioModification, playbackRegion);
-    }
 
     /** Called before a playback region is removed from the audio modification.
         @param audioModification The audio modification that \p playbackRegion will be removed from.
         @param playbackRegion The playback region that will be removed from \p audioModification.
     */
     virtual void willRemovePlaybackRegionFromAudioModification (ARAAudioModification* audioModification,
-                                                                ARAPlaybackRegion* playbackRegion)
+                                                                ARAPlaybackRegion* playbackRegion);
-    {
-        ignoreUnused (audioModification, playbackRegion);
-    }
 
     /** Called before the audio modification is destroyed.
         @param audioModification The audio modification that will be destroyed.
     */
-    virtual void willDestroyAudioModification (ARAAudioModification* audioModification)
+    virtual void willDestroyAudioModification (ARAAudioModification* audioModification);
-    {
-        ignoreUnused (audioModification);
-    }
-
-   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
 };
 
 //==============================================================================

modules/juce_audio_processors/utilities/ARA/juce_ARAPlugInInstanceRoles.cpp

@@ -28,12 +28,10 @@
 namespace juce
 {
 
-bool ARARenderer::processBlock (AudioBuffer<double>& buffer,
+bool ARARenderer::processBlock ([[maybe_unused]] AudioBuffer<double>& buffer,
-                                AudioProcessor::Realtime realtime,
+                                [[maybe_unused]] AudioProcessor::Realtime realtime,
-                                const AudioPlayHead::PositionInfo& positionInfo) noexcept
+                                [[maybe_unused]] const AudioPlayHead::PositionInfo& positionInfo) noexcept
 {
-    ignoreUnused (buffer, realtime, positionInfo);
-
     // If you hit this assertion then either the caller called the double
     // precision version of processBlock on a processor which does not support it
     // (i.e. supportsDoublePrecisionProcessing() returns false), or the implementation
@@ -43,6 +41,12 @@ bool ARARenderer::processBlock (AudioBuffer<double>& buffer,
     return false;
 }
 
+void ARARenderer::prepareToPlay ([[maybe_unused]] double sampleRate,
+                                 [[maybe_unused]] int maximumSamplesPerBlock,
+                                 [[maybe_unused]] int numChannels,
+                                 [[maybe_unused]] AudioProcessor::ProcessingPrecision precision,
+                                 [[maybe_unused]] AlwaysNonRealtime alwaysNonRealtime) {}
+
 //==============================================================================
 #if ARA_VALIDATE_API_CALLS
 void ARAPlaybackRenderer::addPlaybackRegion (ARA::ARAPlaybackRegionRef playbackRegionRef) noexcept
@@ -62,6 +66,21 @@ void ARAPlaybackRenderer::removePlaybackRegion (ARA::ARAPlaybackRegionRef playba
 }
 #endif
 
+bool ARAPlaybackRenderer::processBlock ([[maybe_unused]] AudioBuffer<float>& buffer,
+                                        [[maybe_unused]] AudioProcessor::Realtime realtime,
+                                        [[maybe_unused]] const AudioPlayHead::PositionInfo& positionInfo) noexcept
+{
+    return false;
+}
+
+//==============================================================================
+bool ARAEditorRenderer::processBlock ([[maybe_unused]] AudioBuffer<float>& buffer,
+                                      [[maybe_unused]] AudioProcessor::Realtime isNonRealtime,
+                                      [[maybe_unused]] const AudioPlayHead::PositionInfo& positionInfo) noexcept
+{
+    return true;
+}
+
 //==============================================================================
 void ARAEditorView::doNotifySelection (const ARA::PlugIn::ViewSelection* viewSelection) noexcept
 {
@@ -89,4 +108,7 @@ void ARAEditorView::removeListener (Listener* l)
     listeners.remove (l);
 }
 
+void ARAEditorView::Listener::onNewSelection ([[maybe_unused]] const ARAViewSelection& viewSelection) {}
+void ARAEditorView::Listener::onHideRegionSequences ([[maybe_unused]] const std::vector<ARARegionSequence*>& regionSequences) {}
+
 } // namespace juce

modules/juce_audio_processors/utilities/ARA/juce_ARAPlugInInstanceRoles.h

@@ -59,10 +59,7 @@ public:
                                 int maximumSamplesPerBlock,
                                 int numChannels,
                                 AudioProcessor::ProcessingPrecision precision,
-                                AlwaysNonRealtime alwaysNonRealtime = AlwaysNonRealtime::no)
+                                AlwaysNonRealtime alwaysNonRealtime = AlwaysNonRealtime::no);
-    {
-        ignoreUnused (sampleRate, maximumSamplesPerBlock, numChannels, precision, alwaysNonRealtime);
-    }
 
     /** Frees render resources allocated in prepareToPlay(). */
     virtual void releaseResources() {}
@@ -128,11 +125,7 @@ public:
 
     bool processBlock (AudioBuffer<float>& buffer,
                        AudioProcessor::Realtime realtime,
-                       const AudioPlayHead::PositionInfo& positionInfo) noexcept override
+                       const AudioPlayHead::PositionInfo& positionInfo) noexcept override;
-    {
-        ignoreUnused (buffer, realtime, positionInfo);
-        return false;
-    }
 
     using ARARenderer::processBlock;
 
@@ -191,11 +184,7 @@ public:
     // isNonRealtime of the process context - typically preview is limited to realtime.
     bool processBlock (AudioBuffer<float>& buffer,
                        AudioProcessor::Realtime isNonRealtime,
-                       const AudioPlayHead::PositionInfo& positionInfo) noexcept override
+                       const AudioPlayHead::PositionInfo& positionInfo) noexcept override;
-    {
-        ignoreUnused (buffer, isNonRealtime, positionInfo);
-        return true;
-    }
 
     using ARARenderer::processBlock;
 
@@ -218,7 +207,7 @@ public:
 
     // Shadowing templated getters to default to JUCE versions of the returned classes
     template <typename RegionSequence_t = ARARegionSequence>
-    std::vector<RegionSequence_t*> const& getHiddenRegionSequences() const noexcept
+    const std::vector<RegionSequence_t*>& getHiddenRegionSequences() const noexcept
     {
         return ARA::PlugIn::EditorView::getHiddenRegionSequences<RegionSequence_t>();
     }
@@ -227,7 +216,7 @@ public:
     void doNotifySelection (const ARA::PlugIn::ViewSelection* currentSelection) noexcept override;
 
     // Base class implementation must be called if overridden
-    void doNotifyHideRegionSequences (std::vector<ARA::PlugIn::RegionSequence*> const& regionSequences) noexcept override;
+    void doNotifyHideRegionSequences (const std::vector<ARA::PlugIn::RegionSequence*>& regionSequences) noexcept override;
 
     /** A base class for listeners that want to know about changes to an ARAEditorView object.
 
@@ -239,25 +228,15 @@ public:
         /** Destructor. */
         virtual ~Listener() = default;
 
-       ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN
-
         /** Called when the editor view's selection changes.
             @param viewSelection The current selection state
         */
-        virtual void onNewSelection (const ARAViewSelection& viewSelection)
+        virtual void onNewSelection (const ARAViewSelection& viewSelection);
-        {
-            ignoreUnused (viewSelection);
-        }
 
         /** Called when region sequences are flagged as hidden in the host UI.
             @param regionSequences A vector containing all hidden region sequences.
         */
-        virtual void onHideRegionSequences (std::vector<ARARegionSequence*> const& regionSequences)
+        virtual void onHideRegionSequences (const std::vector<ARARegionSequence*>& regionSequences);
-        {
-            ignoreUnused (regionSequences);
-        }
-
-       ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
     };
 
     /** \copydoc ARAListenableModelClass::addListener */

modules/juce_audio_processors/utilities/juce_AudioProcessorValueTreeState.h

@@ -135,12 +135,7 @@ public:
         void add (std::unique_ptr<Items>... items)
         {
             parameters.reserve (parameters.size() + sizeof... (items));
-
+            (parameters.push_back (makeParameterStorage (std::move (items))), ...);
-            // We can replace this with some nicer code once generic lambdas become available. A
-            // sequential context like an array initialiser is required to ensure we get the correct
-            // order from the parameter pack.
-            int unused[] { (parameters.emplace_back (MakeContents() (std::move (items))), 0)... };
-            ignoreUnused (unused);
         }
 
         template <typename It, typename = ValidIfIterator<It>>
@@ -150,7 +145,7 @@ public:
             std::transform (std::make_move_iterator (begin),
                             std::make_move_iterator (end),
                             std::back_inserter (parameters),
-                            MakeContents());
+                            [] (auto item) { return makeParameterStorage (std::move (item)); });
         }
 
         ParameterLayout (const ParameterLayout& other) = delete;
@@ -191,14 +186,11 @@ public:
             std::unique_ptr<Contents> contents;
         };
 
-        struct MakeContents final
+        template <typename Contents>
+        static std::unique_ptr<ParameterStorage<Contents>> makeParameterStorage (std::unique_ptr<Contents> contents)
         {
-            template <typename Item>
+            return std::make_unique<ParameterStorage<Contents>> (std::move (contents));
-            std::unique_ptr<ParameterStorageBase> operator() (std::unique_ptr<Item> item) const
-            {
-                return std::unique_ptr<ParameterStorageBase> (new ParameterStorage<Item> (std::move (item)));
         }
-        };
 
         void add() {}
 

modules/juce_audio_processors/utilities/juce_PluginHostType.cpp

@@ -56,7 +56,7 @@ void PluginHostType::switchToHostApplication() const
    #endif
 }
 
-bool PluginHostType::isInAAXAudioSuite (AudioProcessor& processor)
+bool PluginHostType::isInAAXAudioSuite ([[maybe_unused]] AudioProcessor& processor)
 {
    #if JucePlugin_Build_AAX
     if (PluginHostType::getPluginLoadedAs() == AudioProcessor::wrapperType_AAX
@@ -66,14 +66,11 @@ bool PluginHostType::isInAAXAudioSuite (AudioProcessor& processor)
     }
    #endif
 
-    ignoreUnused (processor);
     return false;
 }
 
-Image PluginHostType::getHostIcon (int size) const
+Image PluginHostType::getHostIcon ([[maybe_unused]] int size) const
 {
-    ignoreUnused (size);
-
    #if JucePlugin_Enable_IAA && JucePlugin_Build_Standalone && JUCE_IOS && (! JUCE_USE_CUSTOM_PLUGIN_STANDALONE_APP)
     if (isInterAppAudioConnected())
         return juce_getIAAHostIcon (size);

modules/juce_audio_processors/utilities/juce_VSTCallbackHandler.cpp

@@ -0,0 +1,39 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2022 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
+   Agreement and JUCE Privacy Policy.
+
+   End User License Agreement: www.juce.com/juce-7-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+pointer_sized_int VSTCallbackHandler::handleVstPluginCanDo ([[maybe_unused]] int32 index,
+                                                            [[maybe_unused]] pointer_sized_int value,
+                                                            [[maybe_unused]] void* ptr,
+                                                            [[maybe_unused]] float opt)
+{
+    return 0;
+}
+
+void VSTCallbackHandler::handleVstHostCallbackAvailable ([[maybe_unused]] std::function<VstHostCallbackType>&& callback) {}
+
+} // namespace juce

modules/juce_audio_processors/utilities/juce_VSTCallbackHandler.h

@@ -46,11 +46,7 @@ struct VSTCallbackHandler
     virtual pointer_sized_int handleVstPluginCanDo (int32 index,
                                                     pointer_sized_int value,
                                                     void* ptr,
-                                                    float opt)
+                                                    float opt);
-    {
-        ignoreUnused (index, value, ptr, opt);
-        return 0;
-    }
 
     /** This is called by the VST plug-in wrapper when it receives unhandled
         vendor specific calls from the host.
@@ -71,10 +67,7 @@ struct VSTCallbackHandler
     /** This is called once by the VST plug-in wrapper after its constructor.
         You can use the supplied function to query the VST host.
     */
-    virtual void handleVstHostCallbackAvailable (std::function<VstHostCallbackType>&& callback)
+    virtual void handleVstHostCallbackAvailable (std::function<VstHostCallbackType>&& callback);
-    {
-        ignoreUnused (callback);
-    }
 };
 
 } // namespace juce

modules/juce_audio_utils/gui/juce_MidiKeyboardComponent.cpp

@@ -478,4 +478,9 @@ void MidiKeyboardComponent::handleNoteOff (MidiKeyboardState*, int /*midiChannel
     noPendingUpdates.store (false);
 }
 
+//==============================================================================
+bool MidiKeyboardComponent::mouseDownOnKey    ([[maybe_unused]] int midiNoteNumber, [[maybe_unused]] const MouseEvent& e)  { return true; }
+bool MidiKeyboardComponent::mouseDraggedToKey ([[maybe_unused]] int midiNoteNumber, [[maybe_unused]] const MouseEvent& e)  { return true; }
+void MidiKeyboardComponent::mouseUpOnKey      ([[maybe_unused]] int midiNoteNumber, [[maybe_unused]] const MouseEvent& e)  {}
+
 } // namespace juce

modules/juce_audio_utils/gui/juce_MidiKeyboardComponent.h

@@ -193,7 +193,7 @@ public:
 
         @see mouseDraggedToKey
     */
-    virtual bool mouseDownOnKey (int midiNoteNumber, const MouseEvent& e)     { ignoreUnused (midiNoteNumber, e); return true; }
+    virtual bool mouseDownOnKey (int midiNoteNumber, const MouseEvent& e);
 
     /** Callback when the mouse is dragged from one key onto another.
 
@@ -202,13 +202,13 @@ public:
 
         @see mouseDownOnKey
     */
-    virtual bool mouseDraggedToKey (int midiNoteNumber, const MouseEvent& e)  { ignoreUnused (midiNoteNumber, e); return true; }
+    virtual bool mouseDraggedToKey (int midiNoteNumber, const MouseEvent& e);
 
     /** Callback when the mouse is released from a key.
 
         @see mouseDownOnKey
     */
-    virtual void mouseUpOnKey (int midiNoteNumber, const MouseEvent& e)       { ignoreUnused (midiNoteNumber, e); }
+    virtual void mouseUpOnKey (int midiNoteNumber, const MouseEvent& e);
 
     /** Allows text to be drawn on the white notes.
 

modules/juce_audio_utils/native/juce_mac_AudioCDReader.mm

@@ -171,8 +171,7 @@ void AudioCDReader::refreshTrackLengths()
     if (toc.exists())
     {
         XmlDocument doc (toc);
-        const char* error = CDReaderHelpers::getTrackOffsets (doc, trackStartSamples);
+        [[maybe_unused]] const char* error = CDReaderHelpers::getTrackOffsets (doc, trackStartSamples);
-        ignoreUnused (error); // could be logged..
 
         lengthInSamples = trackStartSamples.getLast() - trackStartSamples.getFirst();
     }

modules/juce_core/containers/juce_Array.h

@@ -727,32 +727,7 @@ public:
         @see addSorted, sort
     */
     template <typename ElementComparator, typename TargetValueType>
-    int indexOfSorted (ElementComparator& comparator, TargetValueType elementToLookFor) const
+    int indexOfSorted (ElementComparator& comparator, TargetValueType elementToLookFor) const;
-    {
-        ignoreUnused (comparator); // if you pass in an object with a static compareElements() method, this
-                                   // avoids getting warning messages about the parameter being unused
-
-        const ScopedLockType lock (getLock());
-
-        for (int s = 0, e = values.size();;)
-        {
-            if (s >= e)
-                return -1;
-
-            if (comparator.compareElements (elementToLookFor, values[s]) == 0)
-                return s;
-
-            auto halfway = (s + e) / 2;
-
-            if (halfway == s)
-                return -1;
-
-            if (comparator.compareElements (elementToLookFor, values[halfway]) >= 0)
-                s = halfway;
-            else
-                e = halfway;
-        }
-    }
 
     //==============================================================================
     /** Removes an element from the array.
@@ -1106,14 +1081,7 @@ public:
         @see addSorted, indexOfSorted, sortArray
     */
     template <class ElementComparator>
-    void sort (ElementComparator& comparator,
+    void sort (ElementComparator& comparator, bool retainOrderOfEquivalentItems = false);
-               bool retainOrderOfEquivalentItems = false)
-    {
-        const ScopedLockType lock (getLock());
-        ignoreUnused (comparator); // if you pass in an object with a static compareElements() method, this
-                                   // avoids getting warning messages about the parameter being unused
-        sortArray (comparator, values.begin(), 0, size() - 1, retainOrderOfEquivalentItems);
-    }
 
     //==============================================================================
     /** Returns the CriticalSection that locks this array.
@@ -1150,4 +1118,43 @@ private:
     }
 };
 
+//==============================================================================
+template <typename ElementType, typename TypeOfCriticalSectionToUse, int minimumAllocatedSize>
+template <typename ElementComparator, typename TargetValueType>
+int Array<ElementType, TypeOfCriticalSectionToUse, minimumAllocatedSize>::indexOfSorted (
+    [[maybe_unused]] ElementComparator& comparator,
+    TargetValueType elementToLookFor) const
+{
+    const ScopedLockType lock (getLock());
+
+    for (int s = 0, e = values.size();;)
+    {
+        if (s >= e)
+            return -1;
+
+        if (comparator.compareElements (elementToLookFor, values[s]) == 0)
+            return s;
+
+        auto halfway = (s + e) / 2;
+
+        if (halfway == s)
+            return -1;
+
+        if (comparator.compareElements (elementToLookFor, values[halfway]) >= 0)
+            s = halfway;
+        else
+            e = halfway;
+    }
+}
+
+template <typename ElementType, typename TypeOfCriticalSectionToUse, int minimumAllocatedSize>
+template <class ElementComparator>
+void Array<ElementType, TypeOfCriticalSectionToUse, minimumAllocatedSize>::sort (
+    [[maybe_unused]] ElementComparator& comparator,
+    bool retainOrderOfEquivalentItems)
+{
+    const ScopedLockType lock (getLock());
+    sortArray (comparator, values.begin(), 0, size() - 1, retainOrderOfEquivalentItems);
+}
+
 } // namespace juce

modules/juce_core/containers/juce_ArrayBase.h

@@ -542,7 +542,7 @@ private:
     template <typename... Elements>
     void addImpl (Elements&&... toAdd)
     {
-        ignoreUnused (std::initializer_list<int> { (((void) checkSourceIsNotAMember (toAdd)), 0)... });
+        (checkSourceIsNotAMember (toAdd), ...);
         ensureAllocatedSize (numUsed + (int) sizeof... (toAdd));
         addAssumingCapacityIsReady (std::forward<Elements> (toAdd)...);
     }
@@ -550,7 +550,7 @@ private:
     template <typename... Elements>
     void addAssumingCapacityIsReady (Elements&&... toAdd)
     {
-        ignoreUnused (std::initializer_list<int> { ((void) (new (elements + numUsed++) ElementType (std::forward<Elements> (toAdd))), 0)... });
+        (new (elements + numUsed++) ElementType (std::forward<Elements> (toAdd)), ...);
     }
 
     //==============================================================================

modules/juce_core/containers/juce_ElementComparator.h

@@ -123,7 +123,7 @@ static void sortArray (ElementComparator& comparator,
     @param lastElement      the index of the last element in the range (this is non-inclusive)
 */
 template <class ElementType, class ElementComparator>
-static int findInsertIndexInSortedArray (ElementComparator& comparator,
+static int findInsertIndexInSortedArray ([[maybe_unused]] ElementComparator& comparator,
                                          ElementType* const array,
                                          const ElementType newElement,
                                          int firstElement,
@@ -131,9 +131,6 @@ static int findInsertIndexInSortedArray (ElementComparator& comparator,
 {
     jassert (firstElement <= lastElement);
 
-    ignoreUnused (comparator); // if you pass in an object with a static compareElements() method, this
-                               // avoids getting warning messages about the parameter being unused
-
     while (firstElement < lastElement)
     {
         if (comparator.compareElements (newElement, array [firstElement]) == 0)

modules/juce_core/containers/juce_OwnedArray.h

@@ -46,7 +46,6 @@ namespace juce
 */
 template <class ObjectClass,
           class TypeOfCriticalSectionToUse = DummyCriticalSection>
-
 class OwnedArray
 {
 public:
@@ -531,17 +530,7 @@ public:
         @see add, sort, indexOfSorted
     */
     template <class ElementComparator>
-    int addSorted (ElementComparator& comparator, ObjectClass* newObject) noexcept
+    int addSorted (ElementComparator& comparator, ObjectClass* newObject) noexcept;
-    {
-        // If you pass in an object with a static compareElements() method, this
-        // avoids getting warning messages about the parameter being unused
-        ignoreUnused (comparator);
-
-        const ScopedLockType lock (getLock());
-        auto index = findInsertIndexInSortedArray (comparator, values.begin(), newObject, 0, values.size());
-        insert (index, newObject);
-        return index;
-    }
 
     /** Finds the index of an object in the array, assuming that the array is sorted.
 
@@ -556,33 +545,7 @@ public:
         @see addSorted, sort
     */
     template <typename ElementComparator>
-    int indexOfSorted (ElementComparator& comparator, const ObjectClass* objectToLookFor) const noexcept
+    int indexOfSorted (ElementComparator& comparator, const ObjectClass* objectToLookFor) const noexcept;
-    {
-        // If you pass in an object with a static compareElements() method, this
-        // avoids getting warning messages about the parameter being unused
-        ignoreUnused (comparator);
-
-        const ScopedLockType lock (getLock());
-        int s = 0, e = values.size();
-
-        while (s < e)
-        {
-            if (comparator.compareElements (objectToLookFor, values[s]) == 0)
-                return s;
-
-            auto halfway = (s + e) / 2;
-
-            if (halfway == s)
-                break;
-
-            if (comparator.compareElements (objectToLookFor, values[halfway]) >= 0)
-                s = halfway;
-            else
-                e = halfway;
-        }
-
-        return -1;
-    }
 
     //==============================================================================
     /** Removes an object from the array.
@@ -818,18 +781,7 @@ public:
         @see sortArray, indexOfSorted
     */
     template <class ElementComparator>
-    void sort (ElementComparator& comparator,
+    void sort (ElementComparator& comparator, bool retainOrderOfEquivalentItems = false) noexcept;
-               bool retainOrderOfEquivalentItems = false) noexcept
-    {
-        // If you pass in an object with a static compareElements() method, this
-        // avoids getting warning messages about the parameter being unused
-        ignoreUnused (comparator);
-
-        const ScopedLockType lock (getLock());
-
-        if (size() > 1)
-            sortArray (comparator, values.begin(), 0, size() - 1, retainOrderOfEquivalentItems);
-    }
 
     //==============================================================================
     /** Returns the CriticalSection that locks this array.
@@ -870,4 +822,57 @@ private:
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (OwnedArray)
 };
 
+//==============================================================================
+template <class ObjectClass, class TypeOfCriticalSectionToUse>
+template <class ElementComparator>
+int OwnedArray<ObjectClass, TypeOfCriticalSectionToUse>::addSorted (
+    [[maybe_unused]] ElementComparator& comparator,
+    ObjectClass* newObject) noexcept
+{
+    const ScopedLockType lock (getLock());
+    auto index = findInsertIndexInSortedArray (comparator, values.begin(), newObject, 0, values.size());
+    insert (index, newObject);
+    return index;
+}
+
+template <class ObjectClass, class TypeOfCriticalSectionToUse>
+template <typename ElementComparator>
+int OwnedArray<ObjectClass, TypeOfCriticalSectionToUse>::indexOfSorted (
+    [[maybe_unused]] ElementComparator& comparator,
+    const ObjectClass* objectToLookFor) const noexcept
+{
+    const ScopedLockType lock (getLock());
+    int s = 0, e = values.size();
+
+    while (s < e)
+    {
+        if (comparator.compareElements (objectToLookFor, values[s]) == 0)
+            return s;
+
+        auto halfway = (s + e) / 2;
+
+        if (halfway == s)
+            break;
+
+        if (comparator.compareElements (objectToLookFor, values[halfway]) >= 0)
+            s = halfway;
+        else
+            e = halfway;
+    }
+
+    return -1;
+}
+
+template <class ObjectClass, class TypeOfCriticalSectionToUse>
+template <typename ElementComparator>
+void OwnedArray<ObjectClass, TypeOfCriticalSectionToUse>::sort (
+    [[maybe_unused]] ElementComparator& comparator,
+    bool retainOrderOfEquivalentItems) noexcept
+{
+    const ScopedLockType lock (getLock());
+
+    if (size() > 1)
+        sortArray (comparator, values.begin(), 0, size() - 1, retainOrderOfEquivalentItems);
+}
+
 } // namespace juce

modules/juce_core/containers/juce_ReferenceCountedArray.h

@@ -563,31 +563,7 @@ public:
         @see addSorted, sort
     */
     template <class ElementComparator>
-    int indexOfSorted (ElementComparator& comparator,
+    int indexOfSorted (ElementComparator& comparator, const ObjectClass* objectToLookFor) const noexcept;
-                       const ObjectClass* objectToLookFor) const noexcept
-    {
-        ignoreUnused (comparator);
-        const ScopedLockType lock (getLock());
-        int s = 0, e = values.size();
-
-        while (s < e)
-        {
-            if (comparator.compareElements (objectToLookFor, values[s]) == 0)
-                return s;
-
-            auto halfway = (s + e) / 2;
-
-            if (halfway == s)
-                break;
-
-            if (comparator.compareElements (objectToLookFor, values[halfway]) >= 0)
-                s = halfway;
-            else
-                e = halfway;
-        }
-
-        return -1;
-    }
 
     //==============================================================================
     /** Removes an object from the array.
@@ -828,16 +804,7 @@ public:
         @see sortArray
     */
     template <class ElementComparator>
-    void sort (ElementComparator& comparator,
+    void sort (ElementComparator& comparator, bool retainOrderOfEquivalentItems = false) noexcept;
-               bool retainOrderOfEquivalentItems = false) noexcept
-    {
-        // If you pass in an object with a static compareElements() method, this
-        // avoids getting warning messages about the parameter being unused
-        ignoreUnused (comparator);
-
-        const ScopedLockType lock (getLock());
-        sortArray (comparator, values.begin(), 0, values.size() - 1, retainOrderOfEquivalentItems);
-    }
 
     //==============================================================================
     /** Reduces the amount of storage being used by the array.
@@ -904,4 +871,43 @@ private:
     }
 };
 
+//==============================================================================
+template <class ObjectClass, class TypeOfCriticalSectionToUse>
+template <class ElementComparator>
+int ReferenceCountedArray<ObjectClass, TypeOfCriticalSectionToUse>::indexOfSorted (
+    [[maybe_unused]] ElementComparator& comparator,
+    const ObjectClass* objectToLookFor) const noexcept
+{
+    const ScopedLockType lock (getLock());
+    int s = 0, e = values.size();
+
+    while (s < e)
+    {
+        if (comparator.compareElements (objectToLookFor, values[s]) == 0)
+            return s;
+
+        auto halfway = (s + e) / 2;
+
+        if (halfway == s)
+            break;
+
+        if (comparator.compareElements (objectToLookFor, values[halfway]) >= 0)
+            s = halfway;
+        else
+            e = halfway;
+    }
+
+    return -1;
+}
+
+template <class ObjectClass, class TypeOfCriticalSectionToUse>
+template <class ElementComparator>
+void ReferenceCountedArray<ObjectClass, TypeOfCriticalSectionToUse>::sort (
+    [[maybe_unused]] ElementComparator& comparator,
+    bool retainOrderOfEquivalentItems) noexcept
+{
+    const ScopedLockType lock (getLock());
+    sortArray (comparator, values.begin(), 0, values.size() - 1, retainOrderOfEquivalentItems);
+}
+
 } // namespace juce

modules/juce_core/files/juce_File.cpp

@@ -953,7 +953,7 @@ File File::createTempFile (StringRef fileNameEnding)
 }
 
 bool File::createSymbolicLink (const File& linkFileToCreate,
-                               const String& nativePathOfTarget,
+                               [[maybe_unused]] const String& nativePathOfTarget,
                                bool overwriteExisting)
 {
     if (linkFileToCreate.exists())
@@ -986,7 +986,6 @@ bool File::createSymbolicLink (const File& linkFileToCreate,
                                nativePathOfTarget.toWideCharPointer(),
                                targetFile.isDirectory() ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0) != FALSE;
    #else
-    ignoreUnused (nativePathOfTarget);
     jassertfalse; // symbolic links not supported on this platform!
     return false;
    #endif

modules/juce_core/javascript/juce_Javascript.cpp

@@ -1540,7 +1540,7 @@ struct JavascriptEngine::RootObject   : public DynamicObject
         }
 
         static Identifier getClassName()            { static const Identifier i ("Object"); return i; }
-        static var dump  (Args a)          { DBG (JSON::toString (a.thisObject)); ignoreUnused (a); return var::undefined(); }
+        static var dump  ([[maybe_unused]] Args a)  { DBG (JSON::toString (a.thisObject)); return var::undefined(); }
         static var cloneFn (Args a)                 { return a.thisObject.clone(); }
     };
 

modules/juce_core/maths/juce_Expression.cpp

@@ -424,9 +424,8 @@ struct Expression::Helpers
         String getName() const          { return "-"; }
         TermPtr negated()               { return input; }
 
-        TermPtr createTermToEvaluateInput (const Scope& scope, const Term* t, double overallTarget, Term* topLevelTerm) const
+        TermPtr createTermToEvaluateInput (const Scope& scope, [[maybe_unused]] const Term* t, double overallTarget, Term* topLevelTerm) const
         {
-            ignoreUnused (t);
             jassert (t == input);
 
             const Term* const dest = findDestinationFor (topLevelTerm, this);

modules/juce_core/memory/juce_ContainerDeletePolicy.h

@@ -49,7 +49,7 @@ struct ContainerDeletePolicy
         // implementation of all methods trying to use the OwnedArray (e.g. the destructor
         // of the class owning it) into cpp files where they can see to the definition
         // of ObjectType. This should fix the error.
-        ignoreUnused (sizeof (ObjectType));
+        [[maybe_unused]] constexpr auto size = sizeof (ObjectType);
 
         delete object;
     }

modules/juce_core/native/juce_android_AndroidDocument.cpp

@@ -101,8 +101,7 @@ struct AndroidDocumentDetail
         auto* env = getEnv();
         LocalRef<jobjectArray> array { env->NewObjectArray (sizeof... (args), JavaString, nullptr) };
 
-        int unused[] { (env->SetObjectArrayElement (array.get(), Ix, args.get()), 0)... };
+        (env->SetObjectArrayElement (array.get(), Ix, args.get()), ...);
-        ignoreUnused (unused);
 
         return array;
     }
@@ -745,21 +744,17 @@ struct AndroidDocument::Utils
 };
 
 //==============================================================================
-void AndroidDocumentPermission::takePersistentReadWriteAccess (const URL& url)
+void AndroidDocumentPermission::takePersistentReadWriteAccess ([[maybe_unused]] const URL& url)
 {
    #if JUCE_ANDROID
     AndroidDocumentDetail::setPermissions (url, ContentResolver19.takePersistableUriPermission);
-   #else
-    ignoreUnused (url);
    #endif
 }
 
-void AndroidDocumentPermission::releasePersistentReadWriteAccess (const URL& url)
+void AndroidDocumentPermission::releasePersistentReadWriteAccess ([[maybe_unused]] const URL& url)
 {
    #if JUCE_ANDROID
     AndroidDocumentDetail::setPermissions (url, ContentResolver19.releasePersistableUriPermission);
-   #else
-    ignoreUnused (url);
    #endif
 }
 
@@ -817,7 +812,7 @@ AndroidDocument AndroidDocument::fromFile (const File& filePath)
                                                 : nullptr };
 }
 
-AndroidDocument AndroidDocument::fromDocument (const URL& documentUrl)
+AndroidDocument AndroidDocument::fromDocument ([[maybe_unused]] const URL& documentUrl)
 {
    #if JUCE_ANDROID
     if (getAndroidSDKVersion() < 19)
@@ -839,12 +834,11 @@ AndroidDocument AndroidDocument::fromDocument (const URL& documentUrl)
 
     return AndroidDocument { Utils::createPimplForSdk (javaUri) };
    #else
-    ignoreUnused (documentUrl);
     return AndroidDocument{};
    #endif
 }
 
-AndroidDocument AndroidDocument::fromTree (const URL& treeUrl)
+AndroidDocument AndroidDocument::fromTree ([[maybe_unused]] const URL& treeUrl)
 {
    #if JUCE_ANDROID
     if (getAndroidSDKVersion() < 21)
@@ -874,7 +868,6 @@ AndroidDocument AndroidDocument::fromTree (const URL& treeUrl)
 
     return AndroidDocument { Utils::createPimplForSdk (documentUri) };
    #else
-    ignoreUnused (treeUrl);
     return AndroidDocument{};
    #endif
 }

modules/juce_core/native/juce_mac_Files.mm

@@ -397,7 +397,7 @@ bool DirectoryIterator::NativeIterator::next (String& filenameFound,
 
 
 //==============================================================================
-bool JUCE_CALLTYPE Process::openDocument (const String& fileName, const String& parameters)
+bool JUCE_CALLTYPE Process::openDocument (const String& fileName, [[maybe_unused]] const String& parameters)
 {
     JUCE_AUTORELEASEPOOL
     {
@@ -406,8 +406,6 @@ bool JUCE_CALLTYPE Process::openDocument (const String& fileName, const String&
                                                                                        : [NSURL URLWithString: fileNameAsNS];
 
       #if JUCE_IOS
-        ignoreUnused (parameters);
-
         if (@available (iOS 10.0, *))
         {
             [[UIApplication sharedApplication] openURL: filenameAsURL

modules/juce_core/native/juce_mac_Network.mm

@@ -58,14 +58,12 @@ void MACAddress::findAllAddresses (Array<MACAddress>& result)
 }
 
 //==============================================================================
-bool JUCE_CALLTYPE Process::openEmailWithAttachments (const String& targetEmailAddress,
+bool JUCE_CALLTYPE Process::openEmailWithAttachments ([[maybe_unused]] const String& targetEmailAddress,
-                                                      const String& emailSubject,
+                                                      [[maybe_unused]] const String& emailSubject,
-                                                      const String& bodyText,
+                                                      [[maybe_unused]] const String& bodyText,
-                                                      const StringArray& filesToAttach)
+                                                      [[maybe_unused]] const StringArray& filesToAttach)
 {
   #if JUCE_IOS
-    ignoreUnused (targetEmailAddress, emailSubject, bodyText, filesToAttach);
-
     //xxx probably need to use MFMailComposeViewController
     jassertfalse;
     return false;
@@ -282,9 +280,9 @@ public:
         return newRequest;
     }
 
-    void didFailWithError (NSError* error)
+    void didFailWithError ([[maybe_unused]] NSError* error)
     {
-        DBG (nsStringToJuce ([error description])); ignoreUnused (error);
+        DBG (nsStringToJuce ([error description]));
         nsUrlErrorCode = [error code];
         hasFailed = true;
         initialised = true;
@@ -951,10 +949,8 @@ public:
         connection.reset();
     }
 
-    bool connect (WebInputStream::Listener* webInputListener, int numRetries = 0)
+    bool connect (WebInputStream::Listener* webInputListener, [[maybe_unused]] int numRetries = 0)
     {
-        ignoreUnused (numRetries);
-
         {
             const ScopedLock lock (createConnectionLock);
 

modules/juce_core/native/juce_mac_ObjCHelpers.h

@@ -391,8 +391,8 @@ struct ObjCClass
     template <typename Type>
     void addIvar (const char* name)
     {
-        BOOL b = class_addIvar (cls, name, sizeof (Type), (uint8_t) rint (log2 (sizeof (Type))), @encode (Type));
+        [[maybe_unused]] BOOL b = class_addIvar (cls, name, sizeof (Type), (uint8_t) rint (log2 (sizeof (Type))), @encode (Type));
-        jassert (b); ignoreUnused (b);
+        jassert (b);
     }
 
     template <typename Fn>
@@ -408,8 +408,8 @@ struct ObjCClass
 
     void addProtocol (Protocol* protocol)
     {
-        BOOL b = class_addProtocol (cls, protocol);
+        [[maybe_unused]] BOOL b = class_addProtocol (cls, protocol);
-        jassert (b); ignoreUnused (b);
+        jassert (b);
     }
 
     template <typename ReturnType, typename... Params>

modules/juce_core/native/juce_posix_NamedPipe.cpp

@@ -254,8 +254,7 @@ void NamedPipe::close()
             pimpl->stopReadOperation = true;
 
             const char buffer[] { 0 };
-            const auto done = ::write (pimpl->pipeIn.get(), buffer, numElementsInArray (buffer));
+            [[maybe_unused]] const auto done = ::write (pimpl->pipeIn.get(), buffer, numElementsInArray (buffer));
-            ignoreUnused (done);
         }
     }
 

modules/juce_core/native/juce_posix_SharedCode.h

@@ -140,10 +140,9 @@ bool File::setAsCurrentWorkingDirectory() const
 
 //==============================================================================
 // The unix siginterrupt function is deprecated - this does the same job.
-int juce_siginterrupt (int sig, int flag)
+int juce_siginterrupt ([[maybe_unused]] int sig, [[maybe_unused]] int flag)
 {
    #if JUCE_WASM
-    ignoreUnused (sig, flag);
     return 0;
    #else
     #if JUCE_ANDROID
@@ -693,8 +692,7 @@ int File::getVolumeSerialNumber() const
 void juce_runSystemCommand (const String&);
 void juce_runSystemCommand (const String& command)
 {
-    int result = system (command.toUTF8());
+    [[maybe_unused]] int result = system (command.toUTF8());
-    ignoreUnused (result);
 }
 
 String juce_getOutputFromCommand (const String&);
@@ -1015,7 +1013,7 @@ void JUCE_CALLTYPE Thread::yield()
  #define SUPPORT_AFFINITIES 1
 #endif
 
-void JUCE_CALLTYPE Thread::setCurrentThreadAffinityMask (uint32 affinityMask)
+void JUCE_CALLTYPE Thread::setCurrentThreadAffinityMask ([[maybe_unused]] uint32 affinityMask)
 {
    #if SUPPORT_AFFINITIES
     cpu_set_t affinity;
@@ -1042,7 +1040,6 @@ void JUCE_CALLTYPE Thread::setCurrentThreadAffinityMask (uint32 affinityMask)
     // affinities aren't supported because either the appropriate header files weren't found,
     // or the SUPPORT_AFFINITIES macro was turned off
     jassertfalse;
-    ignoreUnused (affinityMask);
    #endif
 }
 

modules/juce_core/native/juce_win32_Files.cpp

@@ -960,7 +960,7 @@ bool File::createShortcut (const String& description, const File& linkFileToCrea
     ComSmartPtr<IShellLink> shellLink;
     ComSmartPtr<IPersistFile> persistFile;
 
-    ignoreUnused (CoInitialize (nullptr));
+    [[maybe_unused]] const auto result = CoInitialize (nullptr);
 
     return SUCCEEDED (shellLink.CoCreateInstance (CLSID_ShellLink))
         && SUCCEEDED (shellLink->SetPath (getFullPathName().toWideCharPointer()))

modules/juce_core/native/juce_win32_SystemStats.cpp

@@ -457,8 +457,7 @@ public:
        #endif
 
        #if JUCE_WIN32_TIMER_PERIOD > 0
-        auto res = timeBeginPeriod (JUCE_WIN32_TIMER_PERIOD);
+        [[maybe_unused]] auto res = timeBeginPeriod (JUCE_WIN32_TIMER_PERIOD);
-        ignoreUnused (res);
         jassert (res == TIMERR_NOERROR);
        #endif
 

modules/juce_core/native/juce_win32_Threads.cpp

@@ -134,7 +134,7 @@ void Thread::killThread()
     }
 }
 
-void JUCE_CALLTYPE Thread::setCurrentThreadName (const String& name)
+void JUCE_CALLTYPE Thread::setCurrentThreadName ([[maybe_unused]] const String& name)
 {
    #if JUCE_DEBUG && JUCE_MSVC
     struct
@@ -159,8 +159,6 @@ void JUCE_CALLTYPE Thread::setCurrentThreadName (const String& name)
     {
         OutputDebugStringA ("** Warning - Encountered noncontinuable exception **\n");
     }
-   #else
-    ignoreUnused (name);
    #endif
 }
 

modules/juce_core/network/juce_Socket.cpp

@@ -91,15 +91,16 @@ namespace SocketHelpers
                                : setOption (handle, IPPROTO_TCP, TCP_NODELAY, (int) 1));
     }
 
-    static void closeSocket (std::atomic<int>& handle, CriticalSection& readLock,
+    static void closeSocket (std::atomic<int>& handle,
-                             bool isListener, int portNumber, std::atomic<bool>& connected) noexcept
+                             [[maybe_unused]] CriticalSection& readLock,
+                             [[maybe_unused]] bool isListener,
+                             [[maybe_unused]] int portNumber,
+                             std::atomic<bool>& connected) noexcept
     {
         const auto h = (SocketHandle) handle.load();
         handle = -1;
 
        #if JUCE_WINDOWS
-        ignoreUnused (portNumber, isListener, readLock);
-
         if (h != invalidSocket || connected)
             closesocket (h);
 
@@ -771,11 +772,9 @@ bool DatagramSocket::setMulticastLoopbackEnabled (bool enable)
     return SocketHelpers::setOption<bool> ((SocketHandle) handle.load(), IPPROTO_IP, IP_MULTICAST_LOOP, enable);
 }
 
-bool DatagramSocket::setEnablePortReuse (bool enabled)
+bool DatagramSocket::setEnablePortReuse ([[maybe_unused]] bool enabled)
 {
-   #if JUCE_ANDROID
+   #if ! JUCE_ANDROID
-    ignoreUnused (enabled);
-   #else
     if (handle >= 0)
         return SocketHelpers::setOption ((SocketHandle) handle.load(),
                                         #if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD

modules/juce_core/network/juce_URL.cpp

@@ -630,8 +630,7 @@ public:
             }
             else
             {
-                auto desc = [error localizedDescription];
+                [[maybe_unused]] auto desc = [error localizedDescription];
-                ignoreUnused (desc);
                 jassertfalse;
             }
         }
@@ -664,8 +663,7 @@ private:
                 return urlToUse.getLocalFile();
             }
 
-            auto desc = [error localizedDescription];
+            [[maybe_unused]] auto desc = [error localizedDescription];
-            ignoreUnused (desc);
             jassertfalse;
         }
 

modules/juce_core/network/juce_WebInputStream.cpp

@@ -96,4 +96,11 @@ void WebInputStream::createHeadersAndPostData (const URL& aURL,
     aURL.createHeadersAndPostData (headers, data, addParametersToBody);
 }
 
+bool WebInputStream::Listener::postDataSendProgress ([[maybe_unused]] WebInputStream& request,
+                                                     [[maybe_unused]] int bytesSent,
+                                                     [[maybe_unused]] int totalBytes)
+{
+    return true;
+}
+
 } // namespace juce

modules/juce_core/network/juce_WebInputStream.h

@@ -107,11 +107,7 @@ class JUCE_API WebInputStream  : public InputStream
 
             @returns true to continue or false to cancel the upload
         */
-        virtual bool postDataSendProgress (WebInputStream& request, int bytesSent, int totalBytes)
+        virtual bool postDataSendProgress (WebInputStream& request, int bytesSent, int totalBytes);
-        {
-            ignoreUnused (request, bytesSent, totalBytes);
-            return true;
-        }
     };
 
     /** Wait until the first byte is ready for reading.

modules/juce_core/system/juce_StandardHeader.h

@@ -43,8 +43,7 @@
 
 #if ! DOXYGEN
 #define JUCE_VERSION_ID \
-    volatile auto juceVersionId = "juce_version_" JUCE_STRINGIFY(JUCE_MAJOR_VERSION) "_" JUCE_STRINGIFY(JUCE_MINOR_VERSION) "_" JUCE_STRINGIFY(JUCE_BUILDNUMBER); \
+    [[maybe_unused]] volatile auto juceVersionId = "juce_version_" JUCE_STRINGIFY(JUCE_MAJOR_VERSION) "_" JUCE_STRINGIFY(JUCE_MINOR_VERSION) "_" JUCE_STRINGIFY(JUCE_BUILDNUMBER);
-    ignoreUnused (juceVersionId);
 #endif
 
 //==============================================================================

modules/juce_cryptography/encryption/juce_BlowFish.cpp

@@ -280,9 +280,8 @@ void BlowFish::encrypt (MemoryBlock& data) const
     auto size = data.getSize();
     data.setSize (size + (8u - (size % 8u)));
 
-    auto success = encrypt (data.getData(), size, data.getSize());
+    [[maybe_unused]] auto success = encrypt (data.getData(), size, data.getSize());
 
-    ignoreUnused (success);
     jassert (success >= 0);
 }
 

modules/juce_data_structures/juce_data_structures.cpp

@@ -39,6 +39,7 @@
 #include "values/juce_ValueTreeSynchroniser.cpp"
 #include "values/juce_CachedValue.cpp"
 #include "undomanager/juce_UndoManager.cpp"
+#include "undomanager/juce_UndoableAction.cpp"
 #include "app_properties/juce_ApplicationProperties.cpp"
 #include "app_properties/juce_PropertiesFile.cpp"
 

modules/juce_data_structures/undomanager/juce_UndoableAction.cpp

@@ -0,0 +1,31 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2022 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
+   Agreement and JUCE Privacy Policy.
+
+   End User License Agreement: www.juce.com/juce-7-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+UndoableAction* UndoableAction::createCoalescedAction ([[maybe_unused]] UndoableAction* nextAction)  { return nullptr; }
+
+} // namespace juce

modules/juce_data_structures/undomanager/juce_UndoableAction.h

@@ -94,7 +94,7 @@ public:
 
         If it's not possible to merge the two actions, the method should return a nullptr.
     */
-    virtual UndoableAction* createCoalescedAction (UndoableAction* nextAction)  { ignoreUnused (nextAction); return nullptr; }
+    virtual UndoableAction* createCoalescedAction (UndoableAction* nextAction);
 };
 
 } // namespace juce

modules/juce_dsp/containers/juce_FixedSizeFunction.h

@@ -70,10 +70,9 @@ namespace detail
     template <typename Fn>
     void clear (void* s)
     {
-        auto& fn = *reinterpret_cast<Fn*> (s);
-        fn.~Fn();
         // I know this looks insane, for some reason MSVC 14 sometimes thinks fn is unreferenced
-        ignoreUnused (fn);
+        [[maybe_unused]] auto& fn = *reinterpret_cast<Fn*> (s);
+        fn.~Fn();
     }
 
     template <typename Fn, typename Ret, typename... Args>

modules/juce_dsp/containers/juce_FixedSizeFunction_test.cpp

@@ -334,8 +334,8 @@ public:
             bool smallCalled = false;
             bool largeCalled = false;
 
-            SmallFn small = [&smallCalled, a = std::array<char, 8>{}] { smallCalled = true; juce::ignoreUnused (a); };
+            SmallFn small = [&smallCalled, a = std::array<char, 8>{}] { smallCalled = true; ignoreUnused (a); };
-            LargeFn large = [&largeCalled, a = std::array<char, 8>{}] { largeCalled = true; juce::ignoreUnused (a); };
+            LargeFn large = [&largeCalled, a = std::array<char, 8>{}] { largeCalled = true; ignoreUnused (a); };
 
             large = std::move (small);
 

modules/juce_dsp/juce_dsp.h

@@ -208,10 +208,10 @@ namespace juce
             inline void snapToZero (long double& x) noexcept            { JUCE_SNAP_TO_ZERO (x); }
            #endif
           #else
-            inline void snapToZero (float&       x) noexcept            { ignoreUnused (x); }
+            inline void snapToZero ([[maybe_unused]] float&       x) noexcept            {}
            #ifndef DOXYGEN
-            inline void snapToZero (double&      x) noexcept            { ignoreUnused (x); }
+            inline void snapToZero ([[maybe_unused]] double&      x) noexcept            {}
-            inline void snapToZero (long double& x) noexcept            { ignoreUnused (x); }
+            inline void snapToZero ([[maybe_unused]] long double& x) noexcept            {}
            #endif
           #endif
         }

modules/juce_events/native/juce_linux_Messaging.cpp

@@ -68,8 +68,7 @@ public:
 
             ScopedUnlock ul (lock);
             unsigned char x = 0xff;
-            auto numBytes = write (getWriteHandle(), &x, 1);
+            [[maybe_unused]] auto numBytes = write (getWriteHandle(), &x, 1);
-            ignoreUnused (numBytes);
         }
     }
 
@@ -97,8 +96,7 @@ private:
 
             ScopedUnlock ul (lock);
             unsigned char x;
-            auto numBytes = read (fd, &x, 1);
+            [[maybe_unused]] auto numBytes = read (fd, &x, 1);
-            ignoreUnused (numBytes);
         }
 
         return queue.removeAndReturn (0);

modules/juce_events/native/juce_win32_Messaging.cpp

@@ -288,7 +288,7 @@ void MessageManager::broadcastMessage (const String& value)
 //==============================================================================
 void MessageManager::doPlatformSpecificInitialisation()
 {
-    ignoreUnused (OleInitialize (nullptr));
+    [[maybe_unused]] const auto result = OleInitialize (nullptr);
     InternalMessageQueue::getInstance();
 }
 

modules/juce_graphics/native/juce_win32_Direct2DGraphicsContext.cpp

@@ -528,8 +528,8 @@ Direct2DLowLevelGraphicsContext::Direct2DLowLevelGraphicsContext (HWND hwnd_)
 
     if (pimpl->factories->d2dFactory != nullptr)
     {
-        auto hr = pimpl->factories->d2dFactory->CreateHwndRenderTarget ({}, { hwnd, size }, pimpl->renderingTarget.resetAndGetPointerAddress());
+        [[maybe_unused]] auto hr = pimpl->factories->d2dFactory->CreateHwndRenderTarget ({}, { hwnd, size }, pimpl->renderingTarget.resetAndGetPointerAddress());
-        jassert (SUCCEEDED (hr)); ignoreUnused (hr);
+        jassert (SUCCEEDED (hr));
         hr = pimpl->renderingTarget->CreateSolidColorBrush (D2D1::ColorF::ColorF (0.0f, 0.0f, 0.0f, 1.0f), pimpl->colourBrush.resetAndGetPointerAddress());
     }
 }

modules/juce_graphics/native/juce_win32_DirectWriteTypeLayout.cpp

@@ -200,8 +200,7 @@ namespace DirectWriteTypeLayout
             }
 
             ComSmartPtr<IDWriteFont> dwFont;
-            auto hr = fontCollection.GetFontFromFontFace (glyphRun.fontFace, dwFont.resetAndGetPointerAddress());
+            [[maybe_unused]] auto hr = fontCollection.GetFontFromFontFace (glyphRun.fontFace, dwFont.resetAndGetPointerAddress());
-            ignoreUnused (hr);
             jassert (dwFont != nullptr);
 
             ComSmartPtr<IDWriteFontFamily> dwFontFamily;
@@ -299,8 +298,7 @@ namespace DirectWriteTypeLayout
                 fontIndex = 0;
 
             ComSmartPtr<IDWriteFontFamily> fontFamily;
-            auto hr = fontCollection.GetFontFamily (fontIndex, fontFamily.resetAndGetPointerAddress());
+            [[maybe_unused]] auto hr = fontCollection.GetFontFamily (fontIndex, fontFamily.resetAndGetPointerAddress());
-            ignoreUnused (hr);
 
             ComSmartPtr<IDWriteFont> dwFont;
             uint32 fontFacesCount = 0;
@@ -420,8 +418,7 @@ namespace DirectWriteTypeLayout
             return;
 
         UINT32 actualLineCount = 0;
-        auto hr = dwTextLayout->GetLineMetrics (nullptr, 0, &actualLineCount);
+        [[maybe_unused]] auto hr = dwTextLayout->GetLineMetrics (nullptr, 0, &actualLineCount);
-        ignoreUnused (hr);
 
         layout.ensureStorageAllocated ((int) actualLineCount);
 
@@ -486,7 +483,7 @@ static bool canAllTypefacesAndFontsBeUsedInLayout (const AttributedString& text)
 
 #endif
 
-bool TextLayout::createNativeLayout (const AttributedString& text)
+bool TextLayout::createNativeLayout ([[maybe_unused]] const AttributedString& text)
 {
    #if JUCE_USE_DIRECTWRITE
     if (! canAllTypefacesAndFontsBeUsedInLayout (text))
@@ -506,8 +503,6 @@ bool TextLayout::createNativeLayout (const AttributedString& text)
 
         return true;
     }
-   #else
-    ignoreUnused (text);
    #endif
 
     return false;

modules/juce_graphics/native/juce_win32_DirectWriteTypeface.cpp

@@ -35,8 +35,7 @@ namespace
 
         uint32 index = 0;
         BOOL exists = false;
-        auto hr = names->FindLocaleName (L"en-us", &index, &exists);
+        [[maybe_unused]] auto hr = names->FindLocaleName (L"en-us", &index, &exists);
-        ignoreUnused (hr);
 
         if (! exists)
             index = 0;
@@ -152,8 +151,7 @@ public:
         jassert (fontCollection != nullptr);
 
         uint32 fontIndex = 0;
-        auto hr = fontCollection->FindFamilyName (font.getTypefaceName().toWideCharPointer(), &fontIndex, &fontFound);
+        [[maybe_unused]] auto hr = fontCollection->FindFamilyName (font.getTypefaceName().toWideCharPointer(), &fontIndex, &fontFound);
-        ignoreUnused (hr);
 
         if (! fontFound)
             fontIndex = 0;

modules/juce_graphics/native/juce_win32_Fonts.cpp

@@ -234,8 +234,7 @@ StringArray Font::findAllTypefaceStyles (const String& family)
     {
         BOOL fontFound = false;
         uint32 fontIndex = 0;
-        auto hr = factories->systemFonts->FindFamilyName (family.toWideCharPointer(), &fontIndex, &fontFound);
+        [[maybe_unused]] auto hr = factories->systemFonts->FindFamilyName (family.toWideCharPointer(), &fontIndex, &fontFound);
-        ignoreUnused (hr);
 
         if (! fontFound)
             fontIndex = 0;

modules/juce_gui_basics/filebrowser/juce_ContentSharer.cpp

@@ -150,15 +150,13 @@ JUCE_IMPLEMENT_SINGLETON (ContentSharer)
 ContentSharer::ContentSharer() {}
 ContentSharer::~ContentSharer() { clearSingletonInstance(); }
 
-void ContentSharer::shareFiles (const Array<URL>& files,
+void ContentSharer::shareFiles ([[maybe_unused]] const Array<URL>& files,
                                 std::function<void (bool, const String&)> callbackToUse)
 {
   #if JUCE_CONTENT_SHARING
     startNewShare (callbackToUse);
     pimpl->shareFiles (files);
   #else
-    ignoreUnused (files);
-
     // Content sharing is not available on this platform!
     jassertfalse;
 
@@ -188,15 +186,13 @@ void ContentSharer::startNewShare (std::function<void (bool, const String&)> cal
 }
 #endif
 
-void ContentSharer::shareText (const String& text,
+void ContentSharer::shareText ([[maybe_unused]] const String& text,
                                std::function<void (bool, const String&)> callbackToUse)
 {
   #if JUCE_CONTENT_SHARING
     startNewShare (callbackToUse);
     pimpl->shareText (text);
   #else
-    ignoreUnused (text);
-
     // Content sharing is not available on this platform!
     jassertfalse;
 
@@ -205,16 +201,14 @@ void ContentSharer::shareText (const String& text,
   #endif
 }
 
-void ContentSharer::shareImages (const Array<Image>& images,
+void ContentSharer::shareImages ([[maybe_unused]] const Array<Image>& images,
                                  std::function<void (bool, const String&)> callbackToUse,
-                                 ImageFileFormat* imageFileFormatToUse)
+                                 [[maybe_unused]] ImageFileFormat* imageFileFormatToUse)
 {
   #if JUCE_CONTENT_SHARING
     startNewShare (callbackToUse);
     prepareImagesThread.reset (new PrepareImagesThread (*this, images, imageFileFormatToUse));
   #else
-    ignoreUnused (images, imageFileFormatToUse);
-
     // Content sharing is not available on this platform!
     jassertfalse;
 
@@ -238,15 +232,13 @@ void ContentSharer::filesToSharePrepared()
 }
 #endif
 
-void ContentSharer::shareData (const MemoryBlock& mb,
+void ContentSharer::shareData ([[maybe_unused]] const MemoryBlock& mb,
                                std::function<void (bool, const String&)> callbackToUse)
 {
   #if JUCE_CONTENT_SHARING
     startNewShare (callbackToUse);
     prepareDataThread.reset (new PrepareDataThread (*this, mb));
   #else
-    ignoreUnused (mb);
-
     if (callbackToUse)
         callbackToUse (false, "Content sharing not available on this platform!");
   #endif

modules/juce_gui_basics/filebrowser/juce_FileBrowserComponent.cpp

@@ -440,7 +440,7 @@ void FileBrowserComponent::fileDoubleClicked (const File& f)
 
 void FileBrowserComponent::browserRootChanged (const File&) {}
 
-bool FileBrowserComponent::keyPressed (const KeyPress& key)
+bool FileBrowserComponent::keyPressed ([[maybe_unused]] const KeyPress& key)
 {
    #if JUCE_LINUX || JUCE_BSD || JUCE_WINDOWS
     if (key.getModifiers().isCommandDown()
@@ -452,7 +452,6 @@ bool FileBrowserComponent::keyPressed (const KeyPress& key)
     }
    #endif
 
-    ignoreUnused (key);
     return false;
 }
 

modules/juce_gui_basics/layout/juce_SidePanel.cpp

@@ -242,10 +242,8 @@ void SidePanel::lookAndFeelChanged()
     titleLabel.setJustificationType (lf.getSidePanelTitleJustification (*this));
 }
 
-void SidePanel::componentMovedOrResized (Component& component, bool wasMoved, bool wasResized)
+void SidePanel::componentMovedOrResized (Component& component, [[maybe_unused]] bool wasMoved, bool wasResized)
 {
-    ignoreUnused (wasMoved);
-
     if (wasResized && (&component == parent))
         setBounds (calculateBoundsInParent (component));
 }

modules/juce_gui_basics/lookandfeel/juce_LookAndFeel_V3.cpp

@@ -464,10 +464,9 @@ void LookAndFeel_V3::drawLinearSliderBackground (Graphics& g, int x, int y, int
     g.strokePath (indent, PathStrokeType (0.5f));
 }
 
-void LookAndFeel_V3::drawPopupMenuBackground (Graphics& g, int width, int height)
+void LookAndFeel_V3::drawPopupMenuBackground (Graphics& g, [[maybe_unused]] int width, [[maybe_unused]] int height)
 {
     g.fillAll (findColour (PopupMenu::backgroundColourId));
-    ignoreUnused (width, height);
 
    #if ! JUCE_MAC
     g.setColour (findColour (PopupMenu::textColourId).withAlpha (0.6f));

modules/juce_gui_basics/lookandfeel/juce_LookAndFeel_V4.cpp

@@ -353,12 +353,10 @@ void LookAndFeel_V4::drawToggleButton (Graphics& g, ToggleButton& button,
 void LookAndFeel_V4::drawTickBox (Graphics& g, Component& component,
                                   float x, float y, float w, float h,
                                   const bool ticked,
-                                  const bool isEnabled,
+                                  [[maybe_unused]] const bool isEnabled,
-                                  const bool shouldDrawButtonAsHighlighted,
+                                  [[maybe_unused]] const bool shouldDrawButtonAsHighlighted,
-                                  const bool shouldDrawButtonAsDown)
+                                  [[maybe_unused]] const bool shouldDrawButtonAsDown)
 {
-    ignoreUnused (isEnabled, shouldDrawButtonAsHighlighted, shouldDrawButtonAsDown);
-
     Rectangle<float> tickBounds (x, y, w, h);
 
     g.setColour (component.findColour (ToggleButton::tickDisabledColourId));
@@ -619,10 +617,8 @@ int LookAndFeel_V4::getDefaultScrollbarWidth()
 }
 
 void LookAndFeel_V4::drawScrollbar (Graphics& g, ScrollBar& scrollbar, int x, int y, int width, int height,
-                                    bool isScrollbarVertical, int thumbStartPosition, int thumbSize, bool isMouseOver, bool isMouseDown)
+                                    bool isScrollbarVertical, int thumbStartPosition, int thumbSize, bool isMouseOver, [[maybe_unused]] bool isMouseDown)
 {
-    ignoreUnused (isMouseDown);
-
     Rectangle<int> thumbBounds;
 
     if (isScrollbarVertical)
@@ -1253,10 +1249,8 @@ void LookAndFeel_V4::drawPropertyComponentBackground (Graphics& g, int width, in
     g.fillRect  (0, 0, width, height - 1);
 }
 
-void LookAndFeel_V4::drawPropertyComponentLabel (Graphics& g, int width, int height, PropertyComponent& component)
+void LookAndFeel_V4::drawPropertyComponentLabel (Graphics& g, [[maybe_unused]] int width, int height, PropertyComponent& component)
 {
-    ignoreUnused (width);
-
     auto indent = getPropertyComponentIndent (component);
 
     g.setColour (component.findColour (PropertyComponent::labelTextColourId)

modules/juce_gui_basics/menus/juce_PopupMenu.cpp

@@ -2098,7 +2098,7 @@ struct PopupMenuCompletionCallback  : public ModalComponentManager::Callback
 
 int PopupMenu::showWithOptionalCallback (const Options& options,
                                          ModalComponentManager::Callback* userCallback,
-                                         bool canBeModal)
+                                         [[maybe_unused]] bool canBeModal)
 {
     std::unique_ptr<ModalComponentManager::Callback> userCallbackDeleter (userCallback);
     std::unique_ptr<PopupMenuCompletionCallback> callback (new PopupMenuCompletionCallback());
@@ -2120,7 +2120,6 @@ int PopupMenu::showWithOptionalCallback (const Options& options,
         if (userCallback == nullptr && canBeModal)
             return window->runModalLoop();
        #else
-        ignoreUnused (canBeModal);
         jassert (! (userCallback == nullptr && canBeModal));
        #endif
     }

modules/juce_gui_basics/misc/juce_JUCESplashScreen.cpp

@@ -62,10 +62,8 @@ static Rectangle<float> getLogoArea (Rectangle<float> parentRect)
 }
 
 //==============================================================================
-JUCESplashScreen::JUCESplashScreen (Component& parent)
+JUCESplashScreen::JUCESplashScreen ([[maybe_unused]] Component& parent)
 {
-    ignoreUnused (parent);
-
    #if JUCE_DISPLAY_SPLASH_SCREEN
     if (splashDisplayTime == 0
          || Time::getMillisecondCounter() < splashDisplayTime + (uint32) millisecondsToDisplaySplash)