llvm/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

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

#include "ASTResultSynthesizer.h"

#include "ClangASTImporter.h"
#include "ClangPersistentVariables.h"

#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclGroup.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/Expr.h"
#include "clang/AST/Stmt.h"
#include "clang/Parse/Parser.h"
#include "clang/Sema/SemaDiagnostic.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/raw_ostream.h"
#include <cstdlib>

usingnamespacellvm;
usingnamespaceclang;
usingnamespacelldb_private;

ASTResultSynthesizer::ASTResultSynthesizer(ASTConsumer *passthrough,
                                           bool top_level, Target &target)
    : … { … }

ASTResultSynthesizer::~ASTResultSynthesizer() = default;

void ASTResultSynthesizer::Initialize(ASTContext &Context) { … }

void ASTResultSynthesizer::TransformTopLevelDecl(Decl *D) { … }

bool ASTResultSynthesizer::HandleTopLevelDecl(DeclGroupRef D) { … }

bool ASTResultSynthesizer::SynthesizeFunctionResult(FunctionDecl *FunDecl) { … }

bool ASTResultSynthesizer::SynthesizeObjCMethodResult(
    ObjCMethodDecl *MethodDecl) { … }

/// Returns true if LLDB can take the address of the given lvalue for the sake
/// of capturing the expression result. Returns false if LLDB should instead
/// store the expression result in a result variable.
static bool CanTakeAddressOfLValue(const Expr *lvalue_expr) { … }

bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
                                                DeclContext *DC) { … }

void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) { … }

void ASTResultSynthesizer::RecordPersistentTypes(DeclContext *FunDeclCtx) { … }

void ASTResultSynthesizer::MaybeRecordPersistentType(TypeDecl *D) { … }

void ASTResultSynthesizer::RecordPersistentDecl(NamedDecl *D) { … }

void ASTResultSynthesizer::CommitPersistentDecls() { … }

void ASTResultSynthesizer::HandleTagDeclDefinition(TagDecl *D) { … }

void ASTResultSynthesizer::CompleteTentativeDefinition(VarDecl *D) { … }

void ASTResultSynthesizer::HandleVTable(CXXRecordDecl *RD) { … }

void ASTResultSynthesizer::PrintStats() { … }

void ASTResultSynthesizer::InitializeSema(Sema &S) { … }

void ASTResultSynthesizer::ForgetSema() { … }