mfbt/DebugOnly.h
author Dustin J. Mitchell <dustin@mozilla.com>
Wed, 07 Sep 2016 00:10:51 +0000
changeset 354971 1627fd341fc154d4fb771366676b7101204362df
parent 325000 58475d84315a54c9bda2dd19f9f0b9d1b4cb9ac2
child 505383 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1286075: allow optimization of tasks whose dependencies have not been optimized; r=armenzg MikeLing initially did this in bug 1287018. The intent of this conditional was to make optimization faster by not even checking most tasks, based on the assumption that if the prerequisite to a task has changed (for example, a docker image or a build), then naturally we will want to execute that task. However, as we have developed actual optimization methods, this has proven not to be the case: we might want to optimize a test out if its inputs have not changed, even if a new installer has been built. Similarly, SETA may optimize tasks out even if their inputs have changed. MozReview-Commit-ID: LgHET3Z84GB

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * Provides DebugOnly, a type for variables used only in debug builds (i.e. by
 * assertions).
 */

#ifndef mozilla_DebugOnly_h
#define mozilla_DebugOnly_h

#include "mozilla/Attributes.h"

namespace mozilla {

/**
 * DebugOnly contains a value of type T, but only in debug builds.  In release
 * builds, it does not contain a value.  This helper is intended to be used with
 * MOZ_ASSERT()-style macros, allowing one to write:
 *
 *   DebugOnly<bool> check = func();
 *   MOZ_ASSERT(check);
 *
 * more concisely than declaring |check| conditional on #ifdef DEBUG.
 *
 * DebugOnly instances can only be coerced to T in debug builds.  In release
 * builds they don't have a value, so type coercion is not well defined.
 *
 * NOTE: DebugOnly instances still take up one byte of space, plus padding, even
 * in optimized, non-DEBUG builds (see bug 1253094 comment 37 for more info).
 * For this reason the class is MOZ_STACK_CLASS to prevent consumers using
 * DebugOnly for struct/class members and unwittingly inflating the size of
 * their objects in release builds.
 */
template<typename T>
class MOZ_STACK_CLASS DebugOnly
{
public:
#ifdef DEBUG
  T value;

  DebugOnly() { }
  MOZ_IMPLICIT DebugOnly(const T& aOther) : value(aOther) { }
  DebugOnly(const DebugOnly& aOther) : value(aOther.value) { }
  DebugOnly& operator=(const T& aRhs) {
    value = aRhs;
    return *this;
  }

  void operator++(int) { value++; }
  void operator--(int) { value--; }

  // Do not define operator+=(), etc. here.  These will coerce via the
  // implicit cast and built-in operators.  Defining explicit methods here
  // will create ambiguity the compiler can't deal with.

  T* operator&() { return &value; }

  operator T&() { return value; }
  operator const T&() const { return value; }

  T& operator->() { return value; }
  const T& operator->() const { return value; }

#else
  DebugOnly() { }
  MOZ_IMPLICIT DebugOnly(const T&) { }
  DebugOnly(const DebugOnly&) { }
  DebugOnly& operator=(const T&) { return *this; }
  void operator++(int) { }
  void operator--(int) { }
  DebugOnly& operator+=(const T&) { return *this; }
  DebugOnly& operator-=(const T&) { return *this; }
  DebugOnly& operator&=(const T&) { return *this; }
  DebugOnly& operator|=(const T&) { return *this; }
  DebugOnly& operator^=(const T&) { return *this; }
#endif

  /*
   * DebugOnly must always have a destructor or else it will
   * generate "unused variable" warnings, exactly what it's intended
   * to avoid!
   */
  ~DebugOnly() {}
};

} // namespace mozilla

#endif /* mozilla_DebugOnly_h */