EIC code displayed by LXR master/​include/​clang/​ASTMatchers/​Dynamic/​VariantValue.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:36:46

 //===--- VariantValue.h - Polymorphic value type ----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Polymorphic value type.
 ///
 /// Supports all the types required for dynamic Matcher construction.
 ///  Used by the registry to construct matchers in a generic way.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ASTMATCHERS_DYNAMIC_VARIANTVALUE_H
 #define LLVM_CLANG_ASTMATCHERS_DYNAMIC_VARIANTVALUE_H
 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include <memory>
 #include <optional>
 #include <vector>
 
 namespace clang {
 namespace ast_matchers {
 namespace dynamic {
 
 /// Kind identifier.
 ///
 /// It supports all types that VariantValue can contain.
 class ArgKind {
  public:
   enum Kind {
     AK_Matcher,
     AK_Node,
     AK_Boolean,
     AK_Double,
     AK_Unsigned,
     AK_String
   };
   /// Constructor for non-matcher types.
   ArgKind(Kind K) : K(K) { assert(K != AK_Matcher); }
 
   /// Constructor for matcher types.
   static ArgKind MakeMatcherArg(ASTNodeKind MatcherKind) {
     return ArgKind{AK_Matcher, MatcherKind};
   }
 
   static ArgKind MakeNodeArg(ASTNodeKind MatcherKind) {
     return ArgKind{AK_Node, MatcherKind};
   }
 
   Kind getArgKind() const { return K; }
   ASTNodeKind getMatcherKind() const {
     assert(K == AK_Matcher);
     return NodeKind;
   }
   ASTNodeKind getNodeKind() const {
     assert(K == AK_Node);
     return NodeKind;
   }
 
   /// Determines if this type can be converted to \p To.
   ///
   /// \param To the requested destination type.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   conversion.
   bool isConvertibleTo(ArgKind To, unsigned *Specificity) const;
 
   bool operator<(const ArgKind &Other) const {
     if ((K == AK_Matcher && Other.K == AK_Matcher) ||
         (K == AK_Node && Other.K == AK_Node))
       return NodeKind < Other.NodeKind;
     return K < Other.K;
   }
 
   /// String representation of the type.
   std::string asString() const;
 
 private:
   ArgKind(Kind K, ASTNodeKind NK) : K(K), NodeKind(NK) {}
   Kind K;
   ASTNodeKind NodeKind;
 };
 
 using ast_matchers::internal::DynTypedMatcher;
 
 /// A variant matcher object.
 ///
 /// The purpose of this object is to abstract simple and polymorphic matchers
 /// into a single object type.
 /// Polymorphic matchers might be implemented as a list of all the possible
 /// overloads of the matcher. \c VariantMatcher knows how to select the
 /// appropriate overload when needed.
 /// To get a real matcher object out of a \c VariantMatcher you can do:
 ///  - getSingleMatcher() which returns a matcher, only if it is not ambiguous
 ///    to decide which matcher to return. Eg. it contains only a single
 ///    matcher, or a polymorphic one with only one overload.
 ///  - hasTypedMatcher<T>()/getTypedMatcher<T>(): These calls will determine if
 ///    the underlying matcher(s) can unambiguously return a Matcher<T>.
 class VariantMatcher {
   /// Methods that depend on T from hasTypedMatcher/getTypedMatcher.
   class MatcherOps {
   public:
     MatcherOps(ASTNodeKind NodeKind) : NodeKind(NodeKind) {}
 
     bool canConstructFrom(const DynTypedMatcher &Matcher,
                           bool &IsExactMatch) const;
 
     /// Convert \p Matcher the destination type and return it as a new
     /// DynTypedMatcher.
     DynTypedMatcher convertMatcher(const DynTypedMatcher &Matcher) const;
 
     /// Constructs a variadic typed matcher from \p InnerMatchers.
     /// Will try to convert each inner matcher to the destination type and
     /// return std::nullopt if it fails to do so.
     std::optional<DynTypedMatcher>
     constructVariadicOperator(DynTypedMatcher::VariadicOperator Op,
                               ArrayRef<VariantMatcher> InnerMatchers) const;
 
   private:
     ASTNodeKind NodeKind;
   };
 
   /// 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<DynTypedMatcher> getSingleMatcher() const = 0;
     virtual std::string getTypeAsString() const = 0;
     virtual std::optional<DynTypedMatcher>
     getTypedMatcher(const MatcherOps &Ops) const = 0;
     virtual bool isConvertibleTo(ASTNodeKind Kind,
                                  unsigned *Specificity) const = 0;
   };
 
 public:
   /// A null matcher.
   VariantMatcher();
 
   /// Clones the provided matcher.
   static VariantMatcher SingleMatcher(const DynTypedMatcher &Matcher);
 
   /// Clones the provided matchers.
   ///
   /// They should be the result of a polymorphic matcher.
   static VariantMatcher
   PolymorphicMatcher(std::vector<DynTypedMatcher> Matchers);
 
   /// Creates a 'variadic' operator matcher.
   ///
   /// It will bind to the appropriate type on getTypedMatcher<T>().
   static VariantMatcher
   VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op,
                           std::vector<VariantMatcher> Args);
 
   /// Makes the matcher the "null" matcher.
   void reset();
 
   /// Whether the matcher is null.
   bool isNull() const { return !Value; }
 
   /// Return a single matcher, if there is no ambiguity.
   ///
   /// \returns the matcher, if there is only one matcher. An empty Optional, if
   /// the underlying matcher is a polymorphic matcher with more than one
   /// representation.
   std::optional<DynTypedMatcher> getSingleMatcher() const;
 
   /// Determines if the contained matcher can be converted to
   ///   \c Matcher<T>.
   ///
   /// For the Single case, it returns true if it can be converted to
   /// \c Matcher<T>.
   /// For the Polymorphic case, it returns true if one, and only one, of the
   /// overloads can be converted to \c Matcher<T>. If there are more than one
   /// that can, the result would be ambiguous and false is returned.
   template <class T>
   bool hasTypedMatcher() const {
     return hasTypedMatcher(ASTNodeKind::getFromNodeKind<T>());
   }
 
   bool hasTypedMatcher(ASTNodeKind NK) const {
     if (!Value) return false;
     return Value->getTypedMatcher(MatcherOps(NK)).has_value();
   }
 
   /// Determines if the contained matcher can be converted to \p Kind.
   ///
   /// \param Kind the requested destination type.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   conversion.
   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const {
     if (Value)
       return Value->isConvertibleTo(Kind, Specificity);
     return false;
   }
 
   /// Return this matcher as a \c Matcher<T>.
   ///
   /// Handles the different types (Single, Polymorphic) accordingly.
   /// Asserts that \c hasTypedMatcher<T>() is true.
   template <class T>
   ast_matchers::internal::Matcher<T> getTypedMatcher() const {
     assert(hasTypedMatcher<T>() && "hasTypedMatcher<T>() == false");
     return Value->getTypedMatcher(MatcherOps(ASTNodeKind::getFromNodeKind<T>()))
         ->template convertTo<T>();
   }
 
   DynTypedMatcher getTypedMatcher(ASTNodeKind NK) const {
     assert(hasTypedMatcher(NK) && "hasTypedMatcher(NK) == false");
     return *Value->getTypedMatcher(MatcherOps(NK));
   }
 
   /// String representation of the type of the value.
   ///
   /// If the underlying matcher is a polymorphic one, the string will show all
   /// the types.
   std::string getTypeAsString() const;
 
 private:
   explicit VariantMatcher(std::shared_ptr<Payload> Value)
       : Value(std::move(Value)) {}
 
 
   class SinglePayload;
   class PolymorphicPayload;
   class VariadicOpPayload;
 
   std::shared_ptr<const Payload> Value;
 };
 
 /// Variant value class.
 ///
 /// Basically, 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. It supports
 /// copy/assignment.
 ///
 /// Supported types:
 ///  - \c bool
 //   - \c double
 ///  - \c unsigned
 ///  - \c llvm::StringRef
 ///  - \c VariantMatcher (\c DynTypedMatcher / \c Matcher<T>)
 class VariantValue {
 public:
   VariantValue() : Type(VT_Nothing) {}
 
   VariantValue(const VariantValue &Other);
   ~VariantValue();
   VariantValue &operator=(const VariantValue &Other);
 
   /// Specific constructors for each supported type.
   VariantValue(bool Boolean);
   VariantValue(double Double);
   VariantValue(unsigned Unsigned);
   VariantValue(StringRef String);
   VariantValue(ASTNodeKind NodeKind);
   VariantValue(const VariantMatcher &Matchers);
 
   /// Constructs an \c unsigned value (disambiguation from bool).
   VariantValue(int Signed) : VariantValue(static_cast<unsigned>(Signed)) {}
 
   /// Returns true iff this is not an empty value.
   explicit operator bool() const { return hasValue(); }
   bool hasValue() const { return Type != VT_Nothing; }
 
   /// Boolean value functions.
   bool isBoolean() const;
   bool getBoolean() const;
   void setBoolean(bool Boolean);
 
   /// Double value functions.
   bool isDouble() const;
   double getDouble() const;
   void setDouble(double Double);
 
   /// Unsigned value functions.
   bool isUnsigned() const;
   unsigned getUnsigned() const;
   void setUnsigned(unsigned Unsigned);
 
   /// String value functions.
   bool isString() const;
   const std::string &getString() const;
   void setString(StringRef String);
 
   bool isNodeKind() const;
   const ASTNodeKind &getNodeKind() const;
   void setNodeKind(ASTNodeKind NodeKind);
 
   /// Matcher value functions.
   bool isMatcher() const;
   const VariantMatcher &getMatcher() const;
   void setMatcher(const VariantMatcher &Matcher);
 
   /// Determines if the contained value can be converted to \p Kind.
   ///
   /// \param Kind the requested destination type.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   conversion.
   bool isConvertibleTo(ArgKind Kind, unsigned* Specificity) const;
 
   /// Determines if the contained value can be converted to any kind
   /// in \p Kinds.
   ///
   /// \param Kinds the requested destination types.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   conversion. It is the maximum specificity of all the possible
   ///   conversions.
   bool isConvertibleTo(ArrayRef<ArgKind> Kinds, unsigned *Specificity) const;
 
   /// String representation of the type of the value.
   std::string getTypeAsString() const;
 
 private:
   void reset();
 
   /// All supported value types.
   enum ValueType {
     VT_Nothing,
     VT_Boolean,
     VT_Double,
     VT_Unsigned,
     VT_String,
     VT_Matcher,
     VT_NodeKind
   };
 
   /// All supported value types.
   union AllValues {
     unsigned Unsigned;
     double Double;
     bool Boolean;
     std::string *String;
     VariantMatcher *Matcher;
     ASTNodeKind *NodeKind;
   };
 
   ValueType Type;
   AllValues Value;
 };
 
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif // LLVM_CLANG_ASTMATCHERS_DYNAMIC_VARIANTVALUE_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team