llvm/flang/lib/evaluate/expression.h

// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef FORTRAN_EVALUATE_EXPRESSION_H_
#define FORTRAN_EVALUATE_EXPRESSION_H_

// Represent Fortran expressions in a type-safe manner.
// Expressions are the sole owners of their constituents; there is no
// context-independent hash table or sharing of common subexpressions.
// Both deep copy and move semantics are supported for expression construction.
// TODO: variable and function references

#include "common.h"
#include "type.h"
#include <memory>
#include <ostream>
#include <variant>

namespace Fortran::evaluate {

// Some forward definitions
template<int KIND> struct IntegerExpr;
template<int KIND> struct RealExpr;
template<int KIND> struct ComplexExpr;
template<int KIND> struct CharacterExpr;
struct AnyIntegerExpr;
struct AnyRealExpr;
struct AnyComplexExpr;
struct AnyCharacterExpr;
struct AnyIntegerOrRealExpr;

template<typename A> std::unique_ptr<A> DeepCopy(const std::unique_ptr<A> &p) {
  return std::make_unique<A>(const_cast<const A &>(*p));
}

template<typename A> struct Unary {
  Unary(const A &a) : x{std::make_unique<A>(a)} {}
  Unary(std::unique_ptr<const A> &&a) : x{std::move(a)} {}
  Unary(A &&a) : x{std::make_unique<A>(std::move(a))} {}
  Unary(const Unary &that) : x{DeepCopy(that.x)} {}
  Unary(Unary &&) = default;
  std::unique_ptr<const A> x;
};

template<typename A, typename B> struct Binary {
  Binary(const A &a, const B &b)
    : x{std::make_unique<A>(a)}, y{std::make_unique<B>(b)} {}
  Binary(std::unique_ptr<const A> &&a, std::unique_ptr<const B> &&b)
    : x{std::move(a)}, y{std::move(b)} {}
  Binary(A &&a, B &&b)
    : x{std::make_unique<A>(std::move(a))}, y{std::make_unique<B>(
                                                std::move(b))} {}
  Binary(const Binary &that) : x{DeepCopy(that.x)}, y{DeepCopy(that.y)} {}
  Binary(Binary &&) = default;
  std::unique_ptr<const A> x;
  std::unique_ptr<const B> y;
};

template<int KIND> struct IntegerExpr {
  using Result = Type<Category::Integer, KIND>;
  using Constant = typename Result::Value;
  struct Convert : Unary<AnyIntegerOrRealExpr> {
    using Unary<AnyIntegerOrRealExpr>::Unary;
  };
  using Un = Unary<IntegerExpr>;
  using Bin = Binary<IntegerExpr, IntegerExpr>;
  struct Parentheses : public Un {
    using Un::Un;
  };
  struct Negate : public Un {
    using Un::Un;
  };
  struct Add : public Bin {
    using Bin::Bin;
  };
  struct Subtract : public Bin {
    using Bin::Bin;
  };
  struct Multiply : public Bin {
    using Bin::Bin;
  };
  struct Divide : public Bin {
    using Bin::Bin;
  };
  struct Power : public Bin {
    using Bin::Bin;
  };

  IntegerExpr() = delete;
  IntegerExpr(const IntegerExpr &) = default;
  IntegerExpr(IntegerExpr &&) = default;
  IntegerExpr(const Constant &x) : u{x} {}
  IntegerExpr(std::int64_t n) : u{Constant{n}} {}
  IntegerExpr(int n) : u{Constant{n}} {}
  template<typename A> IntegerExpr(A &&x) : u{std::move(x)} {}

  std::ostream &Dump(std::ostream &) const;

  std::variant<Constant, Convert, Parentheses, Negate, Add, Subtract, Multiply,
      Divide, Power>
      u;
};

using DefaultIntegerExpr = IntegerExpr<DefaultInteger::kind>;

template<int KIND> struct RealExpr {
  using Result = Type<Category::Real, KIND>;
  using Constant = typename Result::Value;
  // N.B. Real->Complex and Complex->Real conversions are done with CMPLX
  // and part access operations (resp.).  Conversions between kinds of
  // Complex are done via decomposition to Real and reconstruction.
  struct Convert : Unary<AnyIntegerOrRealExpr> {
    using Unary<AnyIntegerOrRealExpr>::Unary;
  };
  using Un = Unary<RealExpr>;
  using Bin = Binary<RealExpr, RealExpr>;
  struct Parentheses : public Un {
    using Un::Un;
  };
  struct Negate : public Un {
    using Un::Un;
  };
  struct Add : public Bin {
    using Bin::Bin;
  };
  struct Subtract : public Bin {
    using Bin::Bin;
  };
  struct Multiply : public Bin {
    using Bin::Bin;
  };
  struct Divide : public Bin {
    using Bin::Bin;
  };
  struct Power : public Bin {
    using Bin::Bin;
  };
  struct IntPower : public Binary<RealExpr, AnyIntegerExpr> {
    using Binary<RealExpr, AnyIntegerExpr>::Binary;
  };
  using CplxUn = Unary<ComplexExpr<KIND>>;
  struct RealPart : public CplxUn {
    using CplxUn::CplxUn;
  };
  struct AIMAG : public CplxUn {
    using CplxUn::CplxUn;
  };

  RealExpr() = delete;
  RealExpr(const RealExpr &) = default;
  RealExpr(RealExpr &&) = default;
  RealExpr(const Constant &x) : u{x} {}
  template<typename A> RealExpr(A &&x) : u{std::move(x)} {}

  std::ostream &Dump(std::ostream &) const;

  std::variant<Constant, Convert, Parentheses, Negate, Add, Subtract, Multiply,
      Divide, Power, IntPower, RealPart, AIMAG>
      u;
};

template<int KIND> struct ComplexExpr {
  using Result = Type<Category::Complex, KIND>;
  using Constant = typename Result::Value;
  using Un = Unary<ComplexExpr>;
  using Bin = Binary<ComplexExpr, ComplexExpr>;
  struct Parentheses : public Un {
    using Un::Un;
  };
  struct Negate : public Un {
    using Un::Un;
  };
  struct Add : public Bin {
    using Bin::Bin;
  };
  struct Subtract : public Bin {
    using Bin::Bin;
  };
  struct Multiply : public Bin {
    using Bin::Bin;
  };
  struct Divide : public Bin {
    using Bin::Bin;
  };
  struct Power : public Bin {
    using Bin::Bin;
  };
  struct IntPower : public Binary<ComplexExpr, AnyIntegerExpr> {
    using Binary<ComplexExpr, AnyIntegerExpr>::Binary;
  };
  struct CMPLX : public Binary<RealExpr<KIND>, RealExpr<KIND>> {
    using Binary<RealExpr<KIND>, RealExpr<KIND>>::Binary;
  };

  ComplexExpr() = delete;
  ComplexExpr(const ComplexExpr &) = default;
  ComplexExpr(ComplexExpr &&) = default;
  ComplexExpr(const Constant &x) : u{x} {}
  template<typename A> ComplexExpr(A &&x) : u{std::move(x)} {}

  std::ostream &Dump(std::ostream &) const;

  std::variant<Constant, Parentheses, Negate, Add, Subtract, Multiply, Divide,
      Power, IntPower, CMPLX>
      u;
};

template<int KIND> struct CharacterExpr {
  using Result = Type<Category::Character, KIND>;
  using Constant = typename Result::Value;
  using LengthExpr = IntegerExpr<IntrinsicTypeParameterType::kind>;
  struct Concat : public Binary<CharacterExpr, CharacterExpr> {
    using Binary<CharacterExpr, CharacterExpr>::Binary;
  };

  CharacterExpr() = delete;
  CharacterExpr(const CharacterExpr &) = default;
  CharacterExpr(CharacterExpr &&) = default;
  CharacterExpr(const Constant &x) : u{x} {}
  CharacterExpr(Constant &&x) : u{std::move(x)} {}
  CharacterExpr(Concat &&x) : u{std::move(x)} {}

  IntegerExpr<IntrinsicTypeParameterType::kind> LEN() const;
  std::ostream &Dump(std::ostream &) const;

  std::variant<Constant, Concat> u;
};

// The Comparison class template is a helper for constructing logical
// expressions with polymorphism over all of the possible categories and
// kinds of comparable operands.
template<typename T> struct Comparison {
  struct LT : public Binary<T, T> {
    using Binary<T, T>::Binary;
  };
  struct LE : public Binary<T, T> {
    using Binary<T, T>::Binary;
  };
  struct EQ : public Binary<T, T> {
    using Binary<T, T>::Binary;
  };
  struct NE : public Binary<T, T> {
    using Binary<T, T>::Binary;
  };
  struct GE : public Binary<T, T> {
    using Binary<T, T>::Binary;
  };
  struct GT : public Binary<T, T> {
    using Binary<T, T>::Binary;
  };

  Comparison() = delete;
  Comparison(const Comparison &) = default;
  Comparison(Comparison &&) = default;
  template<typename A> Comparison(A &&x) : u{std::move(x)} {}

  std::ostream &Dump(std::ostream &) const;

  std::variant<LT, LE, EQ, NE, GE, GT> u;
};

// COMPLEX admits only .EQ. and .NE. comparisons.
template<int KIND> struct Comparison<ComplexExpr<KIND>> {
  using Bin = Binary<ComplexExpr<KIND>, ComplexExpr<KIND>>;
  struct EQ : public Bin {
    using Bin::Bin;
  };
  struct NE : public Bin {
    using Bin::Bin;
  };

  Comparison() = delete;
  Comparison(const Comparison &) = default;
  Comparison(Comparison &&) = default;
  template<typename A> Comparison(A &&x) : u{std::move(x)} {}

  std::ostream &Dump(std::ostream &) const;

  std::variant<EQ, NE> u;
};

struct IntegerComparison {
  IntegerComparison() = delete;
  IntegerComparison(const IntegerComparison &) = default;
  IntegerComparison(IntegerComparison &&) = default;
  template<typename A> IntegerComparison(A &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  template<int KIND> using C = Comparison<IntegerExpr<KIND>>;
  IntegerKindsVariant<C> u;
};

struct RealComparison {
  RealComparison() = delete;
  RealComparison(const RealComparison &) = default;
  RealComparison(RealComparison &&) = default;
  template<typename A> RealComparison(A &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  template<int KIND> using C = Comparison<RealExpr<KIND>>;
  RealKindsVariant<C> u;
};

struct ComplexComparison {
  ComplexComparison() = delete;
  ComplexComparison(ComplexComparison &&) = default;
  template<typename A> ComplexComparison(A &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  template<int KIND> using C = Comparison<ComplexExpr<KIND>>;
  ComplexKindsVariant<C> u;
};

struct CharacterComparison {
  CharacterComparison() = delete;
  CharacterComparison(const CharacterComparison &) = default;
  CharacterComparison(CharacterComparison &&) = default;
  template<typename A> CharacterComparison(A &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  template<int KIND> using C = Comparison<CharacterExpr<KIND>>;
  CharacterKindsVariant<C> u;
};

// No need to distinguish the various kinds of LOGICAL expression results.
struct LogicalExpr {
  using Constant = bool;
  struct Not : Unary<LogicalExpr> {
    using Unary<LogicalExpr>::Unary;
  };
  using Bin = Binary<LogicalExpr, LogicalExpr>;
  struct And : public Bin {
    using Bin::Bin;
  };
  struct Or : public Bin {
    using Bin::Bin;
  };
  struct Eqv : public Bin {
    using Bin::Bin;
  };
  struct Neqv : public Bin {
    using Bin::Bin;
  };

  LogicalExpr() = delete;
  LogicalExpr(const LogicalExpr &) = default;
  LogicalExpr(LogicalExpr &&) = default;
  LogicalExpr(Constant x) : u{x} {}
  template<int KIND>
  LogicalExpr(const Comparison<IntegerExpr<KIND>> &x)
    : u{IntegerComparison{x}} {}
  template<int KIND>
  LogicalExpr(Comparison<IntegerExpr<KIND>> &&x)
    : u{IntegerComparison{std::move(x)}} {}
  template<int KIND>
  LogicalExpr(const Comparison<RealExpr<KIND>> &x) : u{RealComparison{x}} {}
  template<int KIND>
  LogicalExpr(Comparison<RealExpr<KIND>> &&x)
    : u{RealComparison{std::move(x)}} {}
  template<int KIND>
  LogicalExpr(const Comparison<ComplexExpr<KIND>> &x)
    : u{ComplexComparison{x}} {}
  template<int KIND>
  LogicalExpr(Comparison<ComplexExpr<KIND>> &&x)
    : u{ComplexComparison{std::move(x)}} {}
  template<int KIND>
  LogicalExpr(const Comparison<CharacterExpr<KIND>> &x)
    : u{CharacterComparison{x}} {}
  template<int KIND>
  LogicalExpr(Comparison<CharacterExpr<KIND>> &&x)
    : u{CharacterComparison{std::move(x)}} {}
  template<typename A> LogicalExpr(A &&x) : u{std::move(x)} {}

  std::ostream &Dump(std::ostream &) const;

  std::variant<Constant, Not, And, Or, Eqv, Neqv, IntegerComparison,
      RealComparison, ComplexComparison, CharacterComparison>
      u;
};

// Dynamically polymorphic expressions that can hold any supported kind.
struct AnyIntegerExpr {
  AnyIntegerExpr() = delete;
  AnyIntegerExpr(const AnyIntegerExpr &) = default;
  AnyIntegerExpr(AnyIntegerExpr &&) = default;
  template<int KIND> AnyIntegerExpr(const IntegerExpr<KIND> &x) : u{x} {}
  template<int KIND> AnyIntegerExpr(IntegerExpr<KIND> &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  IntegerKindsVariant<IntegerExpr> u;
};
struct AnyRealExpr {
  AnyRealExpr() = delete;
  AnyRealExpr(const AnyRealExpr &) = default;
  AnyRealExpr(AnyRealExpr &&) = default;
  template<int KIND> AnyRealExpr(const RealExpr<KIND> &x) : u{x} {}
  template<int KIND> AnyRealExpr(RealExpr<KIND> &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  RealKindsVariant<RealExpr> u;
};
struct AnyComplexExpr {
  AnyComplexExpr() = delete;
  AnyComplexExpr(const AnyComplexExpr &) = default;
  AnyComplexExpr(AnyComplexExpr &&) = default;
  template<int KIND> AnyComplexExpr(const ComplexExpr<KIND> &x) : u{x} {}
  template<int KIND> AnyComplexExpr(ComplexExpr<KIND> &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  ComplexKindsVariant<ComplexExpr> u;
};
struct AnyCharacterExpr {
  AnyCharacterExpr() = delete;
  AnyCharacterExpr(const AnyCharacterExpr &) = default;
  AnyCharacterExpr(AnyCharacterExpr &&) = default;
  template<int KIND> AnyCharacterExpr(const CharacterExpr<KIND> &x) : u{x} {}
  template<int KIND>
  AnyCharacterExpr(CharacterExpr<KIND> &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  CharacterKindsVariant<CharacterExpr> u;
};

struct AnyIntegerOrRealExpr {
  AnyIntegerOrRealExpr() = delete;
  AnyIntegerOrRealExpr(const AnyIntegerOrRealExpr &) = default;
  AnyIntegerOrRealExpr(AnyIntegerOrRealExpr &&) = default;
  template<int KIND>
  AnyIntegerOrRealExpr(const IntegerExpr<KIND> &x) : u{AnyIntegerExpr{x}} {}
  template<int KIND>
  AnyIntegerOrRealExpr(IntegerExpr<KIND> &&x)
    : u{AnyIntegerExpr{std::move(x)}} {}
  template<int KIND>
  AnyIntegerOrRealExpr(const RealExpr<KIND> &x) : u{AnyRealExpr{x}} {}
  template<int KIND>
  AnyIntegerOrRealExpr(RealExpr<KIND> &&x) : u{AnyRealExpr{std::move(x)}} {}
  AnyIntegerOrRealExpr(const AnyIntegerExpr &x) : u{x} {}
  AnyIntegerOrRealExpr(AnyIntegerExpr &&x) : u{std::move(x)} {}
  AnyIntegerOrRealExpr(const AnyRealExpr &x) : u{x} {}
  AnyIntegerOrRealExpr(AnyRealExpr &&x) : u{std::move(x)} {}
  std::ostream &Dump(std::ostream &) const;
  std::variant<AnyIntegerExpr, AnyRealExpr> u;
};

// External instantiations
extern template struct IntegerExpr<1>;
extern template struct IntegerExpr<2>;
extern template struct IntegerExpr<4>;
extern template struct IntegerExpr<8>;
extern template struct IntegerExpr<16>;
extern template struct RealExpr<2>;
extern template struct RealExpr<4>;
extern template struct RealExpr<8>;
extern template struct RealExpr<10>;
extern template struct RealExpr<16>;
extern template struct ComplexExpr<2>;
extern template struct ComplexExpr<4>;
extern template struct ComplexExpr<8>;
extern template struct ComplexExpr<10>;
extern template struct ComplexExpr<16>;
extern template struct CharacterExpr<1>;
}  // namespace Fortran::evaluate
#endif  // FORTRAN_EVALUATE_EXPRESSION_H_