llvm/mlir/lib/Dialect/SparseTensor/IR/Detail/Var.h

//===- Var.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
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_DIALECT_SPARSETENSOR_IR_DETAIL_VAR_H
#define MLIR_DIALECT_SPARSETENSOR_IR_DETAIL_VAR_H

#include "TemplateExtras.h"

#include "mlir/IR/OpImplementation.h"
#include "llvm/ADT/EnumeratedArray.h"
#include "llvm/ADT/STLForwardCompat.h"
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/ADT/StringMap.h"

namespace mlir {
namespace sparse_tensor {
namespace ir_detail {

//===----------------------------------------------------------------------===//
/// The three kinds of variables that `Var` can be.
///
/// NOTE: The numerical values used to represent this enum should be
/// treated as an implementation detail, not as part of the API.  In the
/// API below we use the canonical ordering `{Symbol,Dimension,Level}` even
/// though that does not agree with the numerical ordering of the numerical
/// representation.
enum class VarKind { … };

[[nodiscard]] constexpr bool isWF(VarKind vk) { … }

/// Gets the ASCII character used as the prefix when printing `Var`.
constexpr char toChar(VarKind vk) { … }
static_assert …;

//===----------------------------------------------------------------------===//
/// The type of arrays indexed by `VarKind`.
VarKindArray;

//===----------------------------------------------------------------------===//
/// A concrete variable, to be used in our variant of `AffineExpr`.
/// Client-facing class for `VarKind` + `Var::Num` pairs, with RTTI
/// support for subclasses with a fixed `VarKind`.
class Var { … };
static_assert …;

class SymVar final : public Var { … };
static_assert …;

class DimVar final : public Var { … };
static_assert …;

class LvlVar final : public Var { … };
static_assert …;

template <typename U>
constexpr bool Var::isa() const { … }

template <typename U>
constexpr U Var::cast() const { … }

template <typename U>
constexpr std::optional<U> Var::dyn_cast() const { … }

//===----------------------------------------------------------------------===//
// Forward-decl so that we can declare methods of `Ranks` and `VarSet`.
class DimLvlExpr;

//===----------------------------------------------------------------------===//
class Ranks final { … };
static_assert …;

//===----------------------------------------------------------------------===//
/// Efficient representation of a set of `Var`.
class VarSet final { … };

//===----------------------------------------------------------------------===//
/// A record of metadata for/about a variable, used by `VarEnv`.
/// The principal goal of this record is to enable `VarEnv` to be used for
/// incremental parsing; in particular, `VarInfo` allows the `Var::Num` to
/// remain unknown, since each record is instead identified by `VarInfo::ID`.
/// Therefore the `VarEnv` can freely allocate `VarInfo::ID` in whatever
/// order it likes, irrespective of the binding order (`Var::Num`) of the
/// associated variable.
class VarInfo final { … };

//===----------------------------------------------------------------------===//
enum class Policy { … };

//===----------------------------------------------------------------------===//
class VarEnv final { … };

//===----------------------------------------------------------------------===//

} // namespace ir_detail
} // namespace sparse_tensor
} // namespace mlir

#endif // MLIR_DIALECT_SPARSETENSOR_IR_DETAIL_VAR_H