Fix computing same derived function multiple times

[parth-07]

In this discussion I would like to propose a solution for computing same derived function multiple times and would like to discuss improvements to this solution and if this solution is a good fit for clad or not.

Along with solving computing same derived function multiple times, this proposal will also solve:

• Same derivative source code being dumped multiple times on using fdump-derived-fn
• Same derivative source AST being dumped multiple times on using fdump-derived-fn-ast
• Same derivative being written to source file multiple times on using fgenerate-source-file

I would also like to modify behaviour of fdump-source-fn and fdump-source-fn-ast :

• As of now, fdump-source-fn and fdump-source-fn-ast when used with higher order derivatives (clad::differentiate<N>(...)) also dumps derived functions and derived functions AST respectively.
  This feature seems helpful for developers of clad, but for end users this can be surprising.

The proposed solution

Call to compute derivative of a function is made in CladPlugin::ProcessDiffRequest function, here we can check if the requested derivative of a function have already been computed, if yes, then we can reuse the already computed derivative instead of calling m_DerivativeBuilder->Derive(...)

We can check if derived function already exists using derived function name and DeclContext of function to be derived.
For this to work 2 things will always be needed to be true:

• Derived function name uniquely identifies differentiation mode, differentiation order and independent variable.
• Function to be derived and it's corresponding derived functions are always declared in the same declaration context.

Both of these conditions are true as of now in clad :)

I have assumed, the pair {functionName, functionDeclContext} will be unique for functions without any overloads (Please correct me if I am wrong).

Thus we can create a map, std::map<std::pair(const IdentifierInfo*, const DeclContext*), FunctionDecl*> to store derived functions. We will also need a function which returns name of the derived function using the DiffRequest object.

Is DerivativeBuilder a good place for DerivedFns (map object to store derived functions) and getDerivedFnName function ?
If yes, then we will be able to access these in CladPlugin::ProcessDiffRequest using m_DerivativeBuilder member of CladPlugin

Now, few problems with this approach

• Currently we are computing derived function name in ForwardModeVisitor::Derive and ReverseModeVisitor::Derive respectively, computing it 2 times (one in CladPlugin::ProcessDiffRequest) is waste of resources.
  For this,
  We can just compute derived function name in CladPlugin::ProcessDiffRequest and add an attribute derivedFnName in DiffRequest, so we will not need to compute it again in ForwardModeVisitor::Derive and ReverseModeVisitor::Derive.
• Some essential variables of ForwardModeVisitor and ReverseModeVisitor class are assigned to correct value while computing derived function name, if we shift computing derived function name to CladPlugin::ProcessDiffRequest then these variables will not be set to correct value.
  For this too, we can add DiffRequest attributes to store these information.

Please suggest improvements/other ideas for this problem and solution.

[vgvassilev]

That type of discussion should be under a pull request or a bug report as it is very specific for a particular issue.