/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#include <cassert>
#include <string>
#include <iostream>
#include <fstream>
#include <set>
#include "plugin.hxx"
#include "compat.hxx"

/**
if a field is
- a pointer
- only assigned to in the constructor via a new expression
- unconditionally deleted in the destructor
then it can probably just be allocated inline in the parent object

TODO check for cases where the pointer is passed by non-const reference

Be warned that it produces around 5G of log file.

The process goes something like this:
  $ make check
  $ make FORCE_COMPILE=all COMPILER_PLUGIN_TOOL='inlinefields' check
  $ ./compilerplugins/clang/inlinefields.py

and then
  $ for dir in *; do make FORCE_COMPILE=all UPDATE_FILES=$dir COMPILER_PLUGIN_TOOL='inlinefieldsremove' $dir; done
to auto-remove the method declarations

Note that the actual process may involve a fair amount of undoing, hand editing, and general messing around
to get it to work :-)

*/

namespace {

struct MyFieldInfo
{
    std::string parentClass;
    std::string fieldName;
    std::string sourceLocation;
};
bool operator < (const MyFieldInfo &lhs, const MyFieldInfo &rhs)
{
    return std::tie(lhs.parentClass, lhs.fieldName)
         < std::tie(rhs.parentClass, rhs.fieldName);
}


// try to limit the voluminous output a little
static std::set<MyFieldInfo> excludedSet;
static std::set<MyFieldInfo> definitionSet;
static std::set<MyFieldInfo> deletedInDestructorSet;
static std::set<MyFieldInfo> newedInConstructorSet;

class InlineFields:
    public RecursiveASTVisitor<InlineFields>, public loplugin::Plugin
{
public:
    explicit InlineFields(loplugin::InstantiationData const & data):
        Plugin(data) {}

    virtual void run() override
    {
        TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());

        // dump all our output in one write call - this is to try and limit IO "crosstalk" between multiple processes
        // writing to the same logfile
        std::string output;
        for (const MyFieldInfo & s : definitionSet)
            output += "definition:\t" + s.parentClass + "\t" + s.fieldName + "\t" + s.sourceLocation + "\n";
        for (const MyFieldInfo & s : excludedSet)
            output += "excluded:\t" + s.parentClass + "\t" + s.fieldName + "\n";
        for (const MyFieldInfo & s : deletedInDestructorSet)
            output += "deletedInDestructor:\t" + s.parentClass + "\t" + s.fieldName + "\n";
        for (const MyFieldInfo & s : newedInConstructorSet)
            output += "newedInConstructor:\t" + s.parentClass + "\t" + s.fieldName + "\n";
        std::ofstream myfile;
        myfile.open( WORKDIR "/loplugin.inlinefields.log", std::ios::app | std::ios::out);
        myfile << output;
        myfile.close();
    }

    bool shouldVisitTemplateInstantiations () const { return true; }
    bool shouldVisitImplicitCode() const { return true; }

    bool VisitFieldDecl( const FieldDecl* );
    bool VisitCXXConstructorDecl( const CXXConstructorDecl* );
    bool VisitCXXDeleteExpr( const CXXDeleteExpr* );
    bool VisitBinaryOperator( const BinaryOperator* );
private:
    MyFieldInfo niceName(const FieldDecl*);
    void checkTouched(const FieldDecl* fieldDecl, const Expr* memberExpr);
};

MyFieldInfo InlineFields::niceName(const FieldDecl* fieldDecl)
{
    MyFieldInfo aInfo;

    const RecordDecl* recordDecl = fieldDecl->getParent();

    if (const CXXRecordDecl* cxxRecordDecl = dyn_cast<CXXRecordDecl>(recordDecl))
    {
        if (cxxRecordDecl->getTemplateInstantiationPattern())
            cxxRecordDecl = cxxRecordDecl->getTemplateInstantiationPattern();
        aInfo.parentClass = cxxRecordDecl->getQualifiedNameAsString();
    }
    else
        aInfo.parentClass = recordDecl->getQualifiedNameAsString();

    aInfo.fieldName = fieldDecl->getNameAsString();

    SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( fieldDecl->getLocation() );
    StringRef name = getFilenameOfLocation(expansionLoc);
    aInfo.sourceLocation = std::string(name.substr(strlen(SRCDIR)+1)) + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc));
    loplugin::normalizeDotDotInFilePath(aInfo.sourceLocation);

    return aInfo;
}

bool InlineFields::VisitFieldDecl( const FieldDecl* fieldDecl )
{
    fieldDecl = fieldDecl->getCanonicalDecl();
    if (ignoreLocation( fieldDecl )) {
        return true;
    }
    // ignore stuff that forms part of the stable URE interface
    if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(fieldDecl->getLocation()))) {
        return true;
    }
    QualType type = fieldDecl->getType();
    if (!type->isPointerType())
        return true;
    definitionSet.insert(niceName(fieldDecl));
    return true;
}

bool InlineFields::VisitCXXConstructorDecl( const CXXConstructorDecl* decl )
{
    if( ignoreLocation( decl ) )
        return true;
    if (decl->isCopyOrMoveConstructor())
        return true;
    for(auto it = decl->init_begin(); it != decl->init_end(); ++it)
    {
        const CXXCtorInitializer* init = *it;
        const FieldDecl* fieldDecl = init->getMember();
        if( !fieldDecl || !fieldDecl->getType()->isPointerType() )
            continue;
        auto e = init->getInit();
        if (auto parentListExpr = dyn_cast<ParenListExpr>(e))
            e = parentListExpr->getExpr(0);
        e = e->IgnoreParenImpCasts();
        if( isa<CXXNewExpr>(e) )
            newedInConstructorSet.insert(niceName(fieldDecl));
        else if( isa<CXXNullPtrLiteralExpr>(e) || isa<GNUNullExpr>(e))
            ; // ignore
        else
            excludedSet.insert(niceName(fieldDecl));
    }
    return true;
}

static bool isSameParent(const CXXMethodDecl* cxxMethodDecl, const FieldDecl* fieldDecl)
{
    return cxxMethodDecl->getParent() == dyn_cast<CXXRecordDecl>(fieldDecl->getParent());
}

bool InlineFields::VisitBinaryOperator(const BinaryOperator * binaryOp)
{
    if (binaryOp->getOpcode() != BO_Assign) {
        return true;
    }
    if( ignoreLocation( binaryOp ) )
        return true;
    auto memberExpr = dyn_cast<MemberExpr>(binaryOp->getLHS());
    if (!memberExpr)
        return true;
    auto fieldDecl = dyn_cast<FieldDecl>(memberExpr->getMemberDecl());
    if (!fieldDecl || !fieldDecl->getType()->isPointerType()) {
        return true;
    }
    const FunctionDecl* parentFunction = getParentFunctionDecl(binaryOp);
    if (!parentFunction) {
        return true;
    }
    // if the field is being assigned from outside its own constructor or destructor, exclude
    auto constructorDecl = dyn_cast<CXXConstructorDecl>(parentFunction);
    if (constructorDecl && isSameParent(constructorDecl, fieldDecl)) {
        if( isa<CXXNewExpr>(binaryOp->getRHS()) )
            newedInConstructorSet.insert(niceName(fieldDecl));
        else {
            excludedSet.insert(niceName(fieldDecl));
            std::cout << "assign in constructor:" << std::endl;
            binaryOp->getRHS()->dump();
        }
        return true;
    }
    auto destructorDecl = dyn_cast<CXXDestructorDecl>(parentFunction);
    if (destructorDecl && isSameParent(destructorDecl, fieldDecl)) {
        auto e = binaryOp->getRHS()->IgnoreParenImpCasts();
        if( !isa<CXXNullPtrLiteralExpr>(e) && !isa<GNUNullExpr>(e)) {
            excludedSet.insert(niceName(fieldDecl));
            std::cout << "assign in destructor:" << std::endl;
            e->dump();
        }
        return true;
    }
    excludedSet.insert(niceName(fieldDecl));
    return true;
}

bool InlineFields::VisitCXXDeleteExpr(const CXXDeleteExpr * deleteExpr)
{
    if( ignoreLocation( deleteExpr ) )
        return true;
    auto memberExpr = dyn_cast<MemberExpr>(deleteExpr->getArgument()->IgnoreParenImpCasts());
    if (!memberExpr)
        return true;
    auto fieldDecl = dyn_cast<FieldDecl>(memberExpr->getMemberDecl());
    if (!fieldDecl || !fieldDecl->getType()->isPointerType()) {
        return true;
    }
    // TODO for some reason, this part is not working properly, it doesn't find the parent
    // function for delete statements properly
    const FunctionDecl* parentFunction = getParentFunctionDecl(deleteExpr);
    if (!parentFunction) {
        return true;
    }
    auto destructorDecl = dyn_cast<CXXDestructorDecl>(parentFunction);
    if (destructorDecl && isSameParent(destructorDecl, fieldDecl)) {
        deletedInDestructorSet.insert(niceName(fieldDecl));
        return true;
    }
    excludedSet.insert(niceName(fieldDecl));
    return true;
}

loplugin::Plugin::Registration< InlineFields > X("inlinefields", false);

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */