//===--- SourceCodeBuilder.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 "clang/Tooling/Transformer/SourceCodeBuilders.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/Tooling/Transformer/SourceCode.h"

#include "llvm/ADT/Twine.h"

#include <string>

using namespace clang;

using namespace tooling;

const Expr *tooling::reallyIgnoreImplicit(const Expr &E) {

  const Expr *Expr = E.IgnoreImplicit();

  if (const auto *CE = dyn_cast<CXXConstructExpr>(Expr)) {

    if (CE->getNumArgs() > 0 &&

        CE->getArg(0)->getSourceRange() == Expr->getSourceRange())

      return CE->getArg(0)->IgnoreImplicit();

  }

  return Expr;

}

bool tooling::mayEverNeedParens(const Expr &E) {

  const Expr *Expr = reallyIgnoreImplicit(E);

  // We always want parens around unary, binary, and ternary operators, because

  // they are lower precedence.

  if (isa<UnaryOperator>(Expr) || 
isa<BinaryOperator>(Expr)34
 ||

      
isa<AbstractConditionalOperator>(Expr)28
)

    return true;

  // We need parens around calls to all overloaded operators except: function

  // calls, subscripts, and expressions that are already part of an (implicit)

  // call to operator->. These latter are all in the same precedence level as

  // dot/arrow and that level is left associative, so they don't need parens

  // when appearing on the left.

  if (const auto *Op = dyn_cast<CXXOperatorCallExpr>(Expr))

    return Op->getOperator() != OO_Call && Op->getOperator() != OO_Subscript &&

           Op->getOperator() != OO_Arrow;

  return false;

}

bool tooling::needParensAfterUnaryOperator(const Expr &E) {

  const Expr *Expr = reallyIgnoreImplicit(E);

  if (isa<BinaryOperator>(Expr) || 
isa<AbstractConditionalOperator>(Expr)20
)

    return true;

  if (const auto *Op = dyn_cast<CXXOperatorCallExpr>(Expr))

    return Op->getNumArgs() == 2 && 
Op->getOperator() != OO_PlusPlus2
 &&

           
Op->getOperator() != OO_MinusMinus2
 && 
Op->getOperator() != OO_Call2
 &&

           
Op->getOperator() != OO_Subscript2
;

  return false;

}

llvm::Optional<std::string> tooling::buildParens(const Expr &E,

                                                 const ASTContext &Context) {

  StringRef Text = getText(E, Context);

  if (Text.empty())

    return llvm::None;

  if (mayEverNeedParens(E))

    return ("(" + Text + ")").str();

  return Text.str();

}

llvm::Optional<std::string>

tooling::buildDereference(const Expr &E, const ASTContext &Context) {

  if (const auto *Op = dyn_cast<UnaryOperator>(&E))

    if (Op->getOpcode() == UO_AddrOf) {

      // Strip leading '&'.

      StringRef Text =

          getText(*Op->getSubExpr()->IgnoreParenImpCasts(), Context);

      if (Text.empty())

        return llvm::None;

      return Text.str();

    }

  StringRef Text = getText(E, Context);

  if (Text.empty())

    return llvm::None;

  // Add leading '*'.

  if (needParensAfterUnaryOperator(E))

    return ("*(" + Text + ")").str();

  return ("*" + Text).str();

}

llvm::Optional<std::string> tooling::buildAddressOf(const Expr &E,

                                                    const ASTContext &Context) {

  if (E.isImplicitCXXThis())

    return std::string("this");

  if (const auto *Op = dyn_cast<UnaryOperator>(&E))

    if (Op->getOpcode() == UO_Deref) {

      // Strip leading '*'.

      StringRef Text =

          getText(*Op->getSubExpr()->IgnoreParenImpCasts(), Context);

      if (Text.empty())

        return llvm::None;

      return Text.str();

    }

  // Add leading '&'.

  StringRef Text = getText(E, Context);

  if (Text.empty())

    return llvm::None;

  if (needParensAfterUnaryOperator(E)) {

    return ("&(" + Text + ")").str();

  }

  return ("&" + Text).str();

}

llvm::Optional<std::string> tooling::buildDot(const Expr &E,

                                              const ASTContext &Context) {

  if (const auto *Op = llvm::dyn_cast<UnaryOperator>(&E))

    if (Op->getOpcode() == UO_Deref) {

      // Strip leading '*', add following '->'.

      const Expr *SubExpr = Op->getSubExpr()->IgnoreParenImpCasts();

      StringRef DerefText = getText(*SubExpr, Context);

      if (DerefText.empty())

        return llvm::None;

      if (needParensBeforeDotOrArrow(*SubExpr))

        return ("(" + DerefText + ")->").str();

      return (DerefText + "->").str();

    }

  // Add following '.'.

  StringRef Text = getText(E, Context);

  if (Text.empty())

    return llvm::None;

  if (needParensBeforeDotOrArrow(E)) {

    return ("(" + Text + ").").str();

  }

  return (Text + ".").str();

}

llvm::Optional<std::string> tooling::buildArrow(const Expr &E,

                                                const ASTContext &Context) {

  if (const auto *Op = llvm::dyn_cast<UnaryOperator>(&E))

    if (Op->getOpcode() == UO_AddrOf) {

      // Strip leading '&', add following '.'.

      const Expr *SubExpr = Op->getSubExpr()->IgnoreParenImpCasts();

      StringRef DerefText = getText(*SubExpr, Context);

      if (DerefText.empty())

        return llvm::None;

      if (needParensBeforeDotOrArrow(*SubExpr))

        return ("(" + DerefText + ").").str();

      return (DerefText + ".").str();

    }

  // Add following '->'.

  StringRef Text = getText(E, Context);

  if (Text.empty())

    return llvm::None;

  if (needParensBeforeDotOrArrow(E))

    return ("(" + Text + ")->").str();

  return (Text + "->").str();

}