std::unique_ptr AstExpr::Create()

in tools/apiview/parsers/cpp-api-parser/ApiViewProcessor/AstNode.cpp [857:963]
93 lines of code
30 McCabe index (conditional complexity)

std::unique_ptr<AstExpr> AstExpr::Create(Stmt const* statement, ASTContext& context)
{
  if (statement)
  {
    if (isa<Expr>(statement))
    {
      auto expression = cast<Expr>(statement);
      const Expr* actualExpr = expression->IgnoreUnlessSpelledInSource();
      switch (actualExpr->getStmtClass())
      {
        case Stmt::IntegerLiteralClass:
          return std::make_unique<AstIntExpr>(cast<IntegerLiteral>(actualExpr), context);
        case Stmt::StringLiteralClass:
          return std::make_unique<AstStringExpr>(cast<StringLiteral>(actualExpr), context);
        case Stmt::FloatingLiteralClass:
          return std::make_unique<AstFloatExpr>(cast<FloatingLiteral>(actualExpr), context);
        case Stmt::CXXBoolLiteralExprClass:
          return std::make_unique<AstBoolExpr>(cast<CXXBoolLiteralExpr>(actualExpr), context);
        case Stmt::ImplicitCastExprClass:
          return std::make_unique<AstImplicitCastExpr>(cast<ImplicitCastExpr>(actualExpr), context);
        case Stmt::CXXDefaultInitExprClass:
          return std::make_unique<AstDefaultInitExpr>(
              cast<CXXDefaultInitExpr>(actualExpr), context);
        case Stmt::CXXDefaultArgExprClass:
          return std::make_unique<AstDefaultArgExpr>(cast<CXXDefaultArgExpr>(actualExpr), context);
        case Stmt::CXXConstructExprClass:
          return std::make_unique<AstCtorExpr>(cast<CXXConstructExpr>(actualExpr), context);
        case Stmt::DependentScopeDeclRefExprClass:
          return std::make_unique<AstDependentDeclRefExpr>(
              cast<DependentScopeDeclRefExpr>(actualExpr), context);
        case Stmt::DeclRefExprClass:
          return std::make_unique<AstDeclRefExpr>(cast<DeclRefExpr>(actualExpr), context);
        case Stmt::CXXNullPtrLiteralExprClass:
          return std::make_unique<AstNullptrRefExpr>(
              cast<CXXNullPtrLiteralExpr>(actualExpr), context);
        case Stmt::MemberExprClass:
          return std::make_unique<AstMemberExpr>(cast<MemberExpr>(actualExpr), context);
        case Stmt::CXXMemberCallExprClass:
          return std::make_unique<AstMethodCallExpr>(cast<CXXMemberCallExpr>(actualExpr), context);
        case Stmt::InitListExprClass:
          return std::make_unique<AstInitializerList>(cast<InitListExpr>(actualExpr), context);
        case Stmt::UnaryOperatorClass:
          return std::make_unique<AstUnaryOperatorExpr>(cast<UnaryOperator>(actualExpr), context);
        case Stmt::BinaryOperatorClass:
          return std::make_unique<AstBinaryOperatorExpr>(cast<BinaryOperator>(actualExpr), context);
        case Stmt::CXXScalarValueInitExprClass:
          return std::make_unique<AstScalarValueInit>(
              cast<CXXScalarValueInitExpr>(actualExpr), context);
        case Stmt::ImplicitValueInitExprClass:
          return std::make_unique<AstImplicitValueInit>(
              cast<ImplicitValueInitExpr>(actualExpr), context);
        case Stmt::MaterializeTemporaryExprClass:
          // Assert that there is a single child of the MaterializeTemporaryExpr object.
          assert(++actualExpr->child_begin() == actualExpr->child_end());
          return Create(*actualExpr->child_begin(), context);

        case Stmt::CXXTemporaryObjectExprClass:
          return std::make_unique<AstCtorExpr>(cast<CXXConstructExpr>(actualExpr), context);

        case Stmt::CXXConstCastExprClass:
        case Stmt::CXXStaticCastExprClass:
        case Stmt::CXXFunctionalCastExprClass:
          return std::make_unique<AstCastExpr>(cast<CastExpr>(actualExpr), context);

        case Stmt::CXXStdInitializerListExprClass:
          // Assert that there is a single child of the CxxStdInitializerListExpr object.
          assert(++actualExpr->child_begin() == actualExpr->child_end());
          return Create(*actualExpr->child_begin(), context);
        case Stmt::CallExprClass:
          return std::make_unique<AstCallExpr>(cast<CallExpr>(actualExpr), context);
        case Stmt::ExprWithCleanupsClass:
          // Assert that there is a single child of the ExprWithCleanupsClass.
          assert(++actualExpr->child_begin() == actualExpr->child_end());
          return Create(*actualExpr->child_begin(), context);
        case Stmt::CStyleCastExprClass:
          return std::make_unique<AstCStyleCastExpr>(cast<CStyleCastExpr>(actualExpr), context);
        default:
          llvm::errs() << raw_ostream::Colors::RED
                       << "Unknown expression type : " << actualExpr->getStmtClassName()
                       << raw_ostream::Colors::RESET << "\n ";
          actualExpr->dump(llvm::outs(), context);
          return nullptr;
      }
      // else if (isa<CXXNamedCastExpr>(actualExpr))
      //{
      //   return std::make_unique<AstNamedCastExpr>(cast<CXXNamedCastExpr>(actualExpr), context);
      // }
      // else if (isa<CastExpr>(actualExpr))
      //{
      //   return std::make_unique<AstCastExpr>(cast<CastExpr>(actualExpr), context);
      // }
    }
    else
    {
      assert(isa<Stmt>(statement));
      llvm::errs() << raw_ostream::Colors::RED
                   << "Unknown statement type : " << statement->getStmtClassName()
                   << raw_ostream::Colors::RESET << "\n ";
      statement->dump(llvm::outs(), context);
      return nullptr;
    }
  }
  else
  {
    return nullptr;
  }
}