VariantValue.h

Go to the documentation of this file.

//===--- VariantValue.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
//
//===----------------------------------------------------------------------===//
//
// Supports all the types required for dynamic Matcher construction.
// Used by the registry to construct matchers in a generic way.
//
//===----------------------------------------------------------------------===//
 
#ifndef MLIR_TOOLS_MLIRQUERY_MATCHER_VARIANTVALUE_H
#define MLIR_TOOLS_MLIRQUERY_MATCHER_VARIANTVALUE_H
 
#include "ErrorBuilder.h"
#include "MatchersInternal.h"
#include "llvm/ADT/StringRef.h"
 
namespace mlir::query::matcher {
 
// All types that VariantValue can contain.
enum class ArgKind { Boolean, Matcher, Signed, String };
 
// A variant matcher object to abstract simple and complex matchers into a
// single object type.
class VariantMatcher {
  class MatcherOps {
  public:
    std::optional<DynMatcher>
    constructVariadicOperator(DynMatcher::VariadicOperator varOp,
                              ArrayRef<VariantMatcher> innerMatchers) const;
  };
 
  // Payload interface to be specialized by each matcher type. It follows a
  // similar interface as VariantMatcher itself.
  class Payload {
  public:
    virtual ~Payload();
    virtual std::optional<DynMatcher> getDynMatcher() const = 0;
    virtual std::string getTypeAsString() const = 0;
  };
 
public:
  // A null matcher.
  VariantMatcher();
 
  // Clones the provided matcher.
  static VariantMatcher SingleMatcher(DynMatcher matcher);
  static VariantMatcher
  VariadicOperatorMatcher(DynMatcher::VariadicOperator varOp,
                          ArrayRef<VariantMatcher> args);
 
  // Makes the matcher the "null" matcher.
  void reset();
 
  // Checks if the matcher is null.
  bool isNull() const { return !value; }
 
  // Returns the matcher
  std::optional<DynMatcher> getDynMatcher() const;
 
  // String representation of the type of the value.
  std::string getTypeAsString() const;
 
private:
  explicit VariantMatcher(std::shared_ptr<Payload> value)
      : value(std::move(value)) {}
 
  class SinglePayload;
  class VariadicOpPayload;
 
  std::shared_ptr<const Payload> value;
};
 
// Variant value class with a tagged union with value type semantics. It is used
// by the registry as the return value and argument type for the matcher factory
// methods. It can be constructed from any of the supported types:
//  - StringRef
//  - VariantMatcher
class VariantValue {
public:
  VariantValue() : type(ValueType::Nothing) {}
 
  VariantValue(const VariantValue &other);
  ~VariantValue();
  VariantValue &operator=(const VariantValue &other);
 
  // Specific constructors for each supported type.
  VariantValue(const llvm::StringRef string);
  VariantValue(const VariantMatcher &matcher);
  VariantValue(int64_t signedValue);
  VariantValue(bool setBoolean);
 
  // String value functions.
  bool isString() const;
  const llvm::StringRef &getString() const;
  void setString(const llvm::StringRef &string);
 
  // Matcher value functions.
  bool isMatcher() const;
  const VariantMatcher &getMatcher() const;
  void setMatcher(const VariantMatcher &matcher);
 
  // Signed value functions.
  bool isSigned() const;
  int64_t getSigned() const;
  void setSigned(int64_t signedValue);
 
  // Boolean value functions.
  bool isBoolean() const;
  bool getBoolean() const;
  void setBoolean(bool booleanValue);
  // String representation of the type of the value.
  std::string getTypeAsString() const;
  explicit operator bool() const { return hasValue(); }
  bool hasValue() const { return type != ValueType::Nothing; }
 
private:
  void reset();
 
  // All supported value types.
  enum class ValueType {
    Boolean,
    Matcher,
    Nothing,
    Signed,
    String,
  };
 
  // All supported value types.
  union AllValues {
    bool Boolean;
    int64_t Signed;
    llvm::StringRef *String;
    VariantMatcher *Matcher;
  };
 
  ValueType type;
  AllValues value;
};
 
// A VariantValue instance annotated with its parser context.
struct ParserValue {
  ParserValue() {}
  llvm::StringRef text;
  internal::SourceRange range;
  VariantValue value;
};
 
} // namespace mlir::query::matcher
 
#endif // MLIR_TOOLS_MLIRQUERY_MATCHER_VARIANTVALUE_H