StatementContext.h

//===-- StatementContext.h --------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_LOWER_STATEMENTCONTEXT_H
#define FORTRAN_LOWER_STATEMENTCONTEXT_H
 
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include <functional>
#include <optional>
 
namespace mlir {
class Location;
class Region;
} // namespace mlir
 
namespace fir {
class FirOpBuilder;
}
 
namespace Fortran::lower {
 
class StatementContext {
public:
  explicit StatementContext(bool cleanupProhibited = false) {
    if (cleanupProhibited)
      return;
    cufs.push_back({});
  }
 
  ~StatementContext() {
    if (!cufs.empty())
      finalizeAndPop();
    assert(cufs.empty() && "invalid StatementContext destructor call");
  }
 
  using CleanupFunction = std::function<void()>;
 
  void pushScope() {
    assert(!cufs.empty() && "invalid pushScope statement context");
    cufs.push_back({});
  }
 
  void attachCleanup(CleanupFunction cuf) {
    assert(!cufs.empty() && "invalid attachCleanup statement context");
    if (cufs.back()) {
      CleanupFunction oldCleanup = *cufs.back();
      cufs.back() = [=]() {
        cuf();
        oldCleanup();
      };
    } else {
      cufs.back() = cuf;
    }
  }
 
  void finalizeAndKeep() {
    assert(!cufs.empty() && "invalid finalize statement context");
    if (cufs.back())
      (*cufs.back())();
  }
 
  void finalizeAndReset() {
    finalizeAndKeep();
    cufs.back().reset();
  }
 
  void pop() { cufs.pop_back(); }
 
  void finalizeAndPop() {
    finalizeAndKeep();
    pop();
  }
 
  bool hasCode() const {
    return !cufs.empty() && llvm::any_of(cufs, [](auto &opt) -> bool {
      return opt.has_value();
    });
  }
 
private:
  // A statement context should never be copied or moved.
  StatementContext(const StatementContext &) = delete;
  StatementContext &operator=(const StatementContext &) = delete;
  StatementContext(StatementContext &&) = delete;
 
  // Stack of cleanup function "lists" (nested cleanup function calls).
  llvm::SmallVector<std::optional<CleanupFunction>> cufs;
};
 
void genCleanUpInRegionIfAny(mlir::Location loc, fir::FirOpBuilder &builder,
                             mlir::Region &region, StatementContext &context);
 
} // namespace Fortran::lower
 
#endif // FORTRAN_LOWER_STATEMENTCONTEXT_H