VariantValue.cpp | Explore in Territory

//===--- VariantValue.cpp - 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.
///
//===----------------------------------------------------------------------===//

#include "clang/ASTMatchers/Dynamic/VariantValue.h"
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/STLExtras.h"
#include <optional>

namespace clang {
namespace ast_matchers {
namespace dynamic {

std::string ArgKind::asString() const { … }

bool ArgKind::isConvertibleTo(ArgKind To, unsigned *Specificity) const { … }

bool
VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
                                             bool &IsExactMatch) const { … }

DynTypedMatcher VariantMatcher::MatcherOps::convertMatcher(
    const DynTypedMatcher &Matcher) const { … }

std::optional<DynTypedMatcher>
VariantMatcher::MatcherOps::constructVariadicOperator(
    DynTypedMatcher::VariadicOperator Op,
    ArrayRef<VariantMatcher> InnerMatchers) const { … }

VariantMatcher::Payload::~Payload() { … }

class VariantMatcher::SinglePayload : public VariantMatcher::Payload { … };

class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload { … };

class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload { … };

VariantMatcher::VariantMatcher() { … }

VariantMatcher VariantMatcher::SingleMatcher(const DynTypedMatcher &Matcher) { … }

VariantMatcher
VariantMatcher::PolymorphicMatcher(std::vector<DynTypedMatcher> Matchers) { … }

VariantMatcher VariantMatcher::VariadicOperatorMatcher(
    DynTypedMatcher::VariadicOperator Op,
    std::vector<VariantMatcher> Args) { … }

std::optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const { … }

void VariantMatcher::reset() { … }

std::string VariantMatcher::getTypeAsString() const { … }

VariantValue::VariantValue(const VariantValue &Other) : … { … }

VariantValue::VariantValue(bool Boolean) : … { … }

VariantValue::VariantValue(double Double) : … { … }

VariantValue::VariantValue(unsigned Unsigned) : … { … }

VariantValue::VariantValue(StringRef String) : … { … }

VariantValue::VariantValue(ASTNodeKind NodeKind) : … { … }

VariantValue::VariantValue(const VariantMatcher &Matcher) : … { … }

VariantValue::~VariantValue() { … }

VariantValue &VariantValue::operator=(const VariantValue &Other) { … }

void VariantValue::reset() { … }

bool VariantValue::isBoolean() const { … }

bool VariantValue::getBoolean() const { … }

void VariantValue::setBoolean(bool NewValue) { … }

bool VariantValue::isDouble() const { … }

double VariantValue::getDouble() const { … }

void VariantValue::setDouble(double NewValue) { … }

bool VariantValue::isUnsigned() const { … }

unsigned VariantValue::getUnsigned() const { … }

void VariantValue::setUnsigned(unsigned NewValue) { … }

bool VariantValue::isString() const { … }

const std::string &VariantValue::getString() const { … }

void VariantValue::setString(StringRef NewValue) { … }

bool VariantValue::isNodeKind() const { … }

const ASTNodeKind &VariantValue::getNodeKind() const { … }

void VariantValue::setNodeKind(ASTNodeKind NewValue) { … }

bool VariantValue::isMatcher() const { … }

const VariantMatcher &VariantValue::getMatcher() const { … }

void VariantValue::setMatcher(const VariantMatcher &NewValue) { … }

bool VariantValue::isConvertibleTo(ArgKind Kind, unsigned *Specificity) const { … }

bool VariantValue::isConvertibleTo(ArrayRef<ArgKind> Kinds,
                                   unsigned *Specificity) const { … }

std::string VariantValue::getTypeAsString() const { … }

} // end namespace dynamic
} // end namespace ast_matchers
} // end namespace clang
llvm/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
