/*

  This file is part of solidity.

  solidity is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  solidity is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with solidity.  If not, see <http://www.gnu.org/licenses/>.

*/

// SPDX-License-Identifier: GPL-3.0

#pragma once

#include <algorithm>

#include <set>

namespace solidity::yul

{

/**

 * Side effects of code.

 *

 * The default-constructed value applies to the "empty code".

 */

struct SideEffects

{

  /// Corresponds to the effect that a Yul-builtin has on a generic data location (storage, memory

  /// and other blockchain state).

  enum Effect

  {

    None,

    Read,

    Write

  };

  friend Effect operator+(Effect const& _a, Effect const& _b)

  {

    return static_cast<Effect>(std::max(static_cast<int>(_a), static_cast<int>(_b)));

  }

  /// If true, expressions in this code can be freely moved and copied without altering the

  /// semantics.

  /// At statement level, it means that functions containing this code can be

  /// called multiple times, their calls can be rearranged and calls can also be

  /// deleted without changing the semantics.

  /// This means it cannot depend on storage, memory or transient storage, cannot have any side-effects,

  /// but it can depend on state that is constant across an EVM-call.

  bool movable = true;

  /// If true, the expressions in this code can be moved or copied (together with their arguments)

  /// across control flow branches and instructions as long as these instructions' 'effects' do

  /// not influence the 'effects' of the aforementioned expressions.

  bool movableApartFromEffects = true;

  /// If true, the code can be removed without changing the semantics.

  bool canBeRemoved = true;

  /// If true, the code can be removed without changing the semantics as long as

  /// the whole program does not contain the msize instruction.

  bool canBeRemovedIfNoMSize = true;

  /// If false, the code calls a for-loop or a recursive function, and therefore potentially loops

  /// infinitely. All builtins are set to true by default, even `invalid()`.

  bool cannotLoop = true;

  /// Can write, read or have no effect on the blockchain state, when the value of `otherState` is

  /// `Write`, `Read` or `None` respectively.

  Effect otherState = None;

  /// Can write, read or have no effect on storage, when the value of `storage` is `Write`, `Read`

  /// or `None` respectively. When the value is `Write`, the expression can invalidate storage,

  /// potentially indirectly through external calls.

  Effect storage = None;

  /// Can write, read or have no effect on memory, when the value of `memory` is `Write`, `Read`

  /// or `None` respectively. Note that, when the value is `Read`, the expression can have an

  /// effect on `msize()`.

  Effect memory = None;

  /// Can write, read or have no effect on transient storage, when the value of `transientStorage` is `Write`, `Read`

  /// or `None` respectively.  When the value is `Write`, the expression can invalidate transient storage,

  /// potentially indirectly through external calls.

  Effect transientStorage = None;

  /// @returns the worst-case side effects.

  static SideEffects worst()

  {

    return SideEffects{false, false, false, false, false, Write, Write, Write, Write};

  }

  /// @returns the combined side effects of two pieces of code.

  SideEffects operator+(SideEffects const& _other)

  {

    return SideEffects{

      movable && _other.movable,

      movableApartFromEffects && _other.movableApartFromEffects,

      canBeRemoved && _other.canBeRemoved,

      canBeRemovedIfNoMSize && _other.canBeRemovedIfNoMSize,

      cannotLoop && _other.cannotLoop,

      otherState + _other.otherState,

      storage + _other.storage,

      memory + _other.memory,

      transientStorage + _other.transientStorage

    };

  }

  /// Adds the side effects of another piece of code to this side effect.

  SideEffects& operator+=(SideEffects const& _other)

  {

    *this = *this + _other;

    return *this;

  }

  bool operator==(SideEffects const& _other) const

  {

    return

      movable == _other.movable &&

      movableApartFromEffects == _other.movableApartFromEffects &&

      canBeRemoved == _other.canBeRemoved &&

      canBeRemovedIfNoMSize == _other.canBeRemovedIfNoMSize &&

      cannotLoop == _other.cannotLoop &&

      otherState == _other.otherState &&

      storage == _other.storage &&

      memory == _other.memory &&

      transientStorage == _other.transientStorage;

  }

};

}