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

//

//===----------------------------------------------------------------------===//

#include "PtrTypesSemantics.h"

#include "ASTUtils.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/ExprCXX.h"

#include <optional>

using namespace clang;

namespace {

bool hasPublicRefAndDeref(const CXXRecordDecl *R) {

  assert(R);

  assert(R->hasDefinition());

  bool hasRef = false;

  bool hasDeref = false;

  for (const CXXMethodDecl *MD : R->methods()) {

    const auto MethodName = safeGetName(MD);

    if (MethodName == "ref" && 
MD->getAccess() == AS_public76
) {

      if (hasDeref)

        return true;

      hasRef = true;

    } else if (MethodName == "deref" && 
MD->getAccess() == AS_public76
) {

      if (hasRef)

        return true;

      hasDeref = true;

    }

  }

  return false;

}

} // namespace

namespace clang {

std::optional<const clang::CXXRecordDecl*>

isRefCountable(const CXXBaseSpecifier* Base)

{

  assert(Base);

  const Type *T = Base->getType().getTypePtrOrNull();

  if (!T)

    return std::nullopt;

  const CXXRecordDecl *R = T->getAsCXXRecordDecl();

  if (!R)

    return std::nullopt;

  if (!R->hasDefinition())

    return std::nullopt;

  return hasPublicRefAndDeref(R) ? 
R5
 : 
nullptr4
;

}

std::optional<bool> isRefCountable(const CXXRecordDecl* R)

{

  assert(R);

  R = R->getDefinition();

  if (!R)

    return std::nullopt;

  if (hasPublicRefAndDeref(R))

    return true;

  CXXBasePaths Paths;

  Paths.setOrigin(const_cast<CXXRecordDecl *>(R));

  bool AnyInconclusiveBase = false;

  const auto isRefCountableBase =

      [&AnyInconclusiveBase](const CXXBaseSpecifier* Base, CXXBasePath&) {

          std::optional<const clang::CXXRecordDecl*> IsRefCountable = clang::isRefCountable(Base);

          if (!IsRefCountable) {

              AnyInconclusiveBase = true;

              return false;

          }

          return (*IsRefCountable) != nullptr;

      };

  bool BasesResult = R->lookupInBases(isRefCountableBase, Paths,

                                      /*LookupInDependent =*/true);

  if (AnyInconclusiveBase)

    return std::nullopt;

  return BasesResult;

}

bool isCtorOfRefCounted(const clang::FunctionDecl *F) {

  assert(F);

  const auto &FunctionName = safeGetName(F);

  return FunctionName == "Ref" || FunctionName == "makeRef"

         || 
FunctionName == "RefPtr"112
 || 
FunctionName == "makeRefPtr"112

         || 
FunctionName == "UniqueRef"111
 || 
FunctionName == "makeUniqueRef"111
 ||

         
FunctionName == "makeUniqueRefWithoutFastMallocCheck"111

         || 
FunctionName == "String"111
 || 
FunctionName == "AtomString"111
 ||

         
FunctionName == "UniqueString"111

         // FIXME: Implement as attribute.

         || 
FunctionName == "Identifier"111
;

}

std::optional<bool> isUncounted(const CXXRecordDecl* Class)

{

  // Keep isRefCounted first as it's cheaper.

  if (isRefCounted(Class))

    return false;

  std::optional<bool> IsRefCountable = isRefCountable(Class);

  if (!IsRefCountable)

    return std::nullopt;

  return (*IsRefCountable);

}

std::optional<bool> isUncountedPtr(const Type* T)

{

  assert(T);

  if (T->isPointerType() || 
T->isReferenceType()29
) {

    if (auto *CXXRD = T->getPointeeCXXRecordDecl()) {

      return isUncounted(CXXRD);

    }

  }

  return false;

}

std::optional<bool> isGetterOfRefCounted(const CXXMethodDecl* M)

{

  assert(M);

  if (isa<CXXMethodDecl>(M)) {

    const CXXRecordDecl *calleeMethodsClass = M->getParent();

    auto className = safeGetName(calleeMethodsClass);

    auto methodName = safeGetName(M);

    if (((className == "Ref" || 
className == "RefPtr"13
) &&

         
methodName == "get"10
) ||

        
(8
(8
className == "String"8
 || 
className == "AtomString"7
 ||

          
className == "AtomStringImpl"6
 || 
className == "UniqueString"6
 ||

          
className == "UniqueStringImpl"6
 || 
className == "Identifier"6
) &&

         
methodName == "impl"2
))

      return true;

    // Ref<T> -> T conversion

    // FIXME: Currently allowing any Ref<T> -> whatever cast.

    if (className == "Ref" || 
className == "RefPtr"4
) {

      if (auto *maybeRefToRawOperator = dyn_cast<CXXConversionDecl>(M)) {

        if (auto *targetConversionType =

                maybeRefToRawOperator->getConversionType().getTypePtrOrNull()) {

          return isUncountedPtr(targetConversionType);

        }

      }

    }

  }

  return false;

}

bool isRefCounted(const CXXRecordDecl *R) {

  assert(R);

  if (auto *TmplR = R->getTemplateInstantiationPattern()) {

    // FIXME: String/AtomString/UniqueString

    const auto &ClassName = safeGetName(TmplR);

    return ClassName == "RefPtr" || 
ClassName == "Ref"3
;

  }

  return false;

}

bool isPtrConversion(const FunctionDecl *F) {

  assert(F);

  if (isCtorOfRefCounted(F))

    return true;

  // FIXME: check # of params == 1

  const auto FunctionName = safeGetName(F);

  if (FunctionName == "getPtr" || FunctionName == "WeakPtr" ||

      FunctionName == "makeWeakPtr"

      || FunctionName == "downcast" || 
FunctionName == "bitwise_cast"20
)

    return true;

  return false;

}

} // namespace clang