private boolean maybeAddReferenceUsingMode(
NodeTraversal t, FunctionState fs, Node callNode, JSModule module, InliningMode mode) {
// If many functions are inlined into the same function F in the same
// inlining round, then the size of F may exceed the max size.
// This could be avoided if we bail later, during the inlining phase, eg,
// in Inline#visitCallSite. However, that is not safe, because at that
// point expression decomposition has already run, and we want to
// decompose expressions only for the calls that are actually inlined.
if (enforceMaxSizeAfterInlining && targetSizeAfterInlineExceedsLimit(t, fs)) {
return false;
}
Reference candidate = new Reference(callNode, t.getScope(), module, mode);
CanInlineResult result =
injector.canInlineReferenceToFunction(
candidate,
fs.getFn().getFunctionNode(),
fs.getNamesToAlias(),
fs.getReferencesThis(),
fs.hasInnerFunctions());
if (result != CanInlineResult.NO) {
// Yeah!
candidate.setRequiresDecomposition(result == CanInlineResult.AFTER_PREPARATION);
fs.addReference(candidate);
return true;
}
return false;
}
private boolean maybeAddReferenceUsingMode(
NodeTraversal t, FunctionState fs, Node callNode, JSModule module, InliningMode mode) {
if (specializationState != null) {
// If we're specializing, make sure we can fixup
// the containing function before inlining
Node containingFunction = getContainingFunction(t);
if (containingFunction != null
&& !specializationState.canFixupFunction(containingFunction)) {
return false;
}
}
CanInlineResult result =
injector.canInlineReferenceToFunction(
t,
callNode,
fs.getFn().getFunctionNode(),
fs.getNamesToAlias(),
mode,
fs.getReferencesThis(),
fs.hasInnerFunctions());
if (result != CanInlineResult.NO) {
// Yeah!
boolean decompose = (result == CanInlineResult.AFTER_PREPARATION);
fs.addReference(new Reference(callNode, module, mode, decompose));
return true;
}
return false;
}
