JS: convert JsInliner to Kotlin
This commit is contained in:
Anton Bannykh
@@ -1,757 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
|
|
||||||
* that can be found in the license/LICENSE.txt file.
|
|
||||||
*/
|
|
||||||
|
|
||||||
package org.jetbrains.kotlin.js.inline;
|
|
||||||
|
|
||||||
import com.intellij.psi.PsiElement;
|
|
||||||
import kotlin.jvm.functions.Function1;
|
|
||||||
import org.jetbrains.annotations.NotNull;
|
|
||||||
import org.jetbrains.annotations.Nullable;
|
|
||||||
import org.jetbrains.kotlin.backend.common.CommonCoroutineCodegenUtilKt;
|
|
||||||
import org.jetbrains.kotlin.config.CommonConfigurationKeysKt;
|
|
||||||
import org.jetbrains.kotlin.config.LanguageVersionSettings;
|
|
||||||
import org.jetbrains.kotlin.descriptors.CallableDescriptor;
|
|
||||||
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
|
|
||||||
import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
|
|
||||||
import org.jetbrains.kotlin.diagnostics.DiagnosticSink;
|
|
||||||
import org.jetbrains.kotlin.diagnostics.Errors;
|
|
||||||
import org.jetbrains.kotlin.js.backend.ast.*;
|
|
||||||
import org.jetbrains.kotlin.js.backend.ast.metadata.MetadataProperties;
|
|
||||||
import org.jetbrains.kotlin.js.config.JsConfig;
|
|
||||||
import org.jetbrains.kotlin.js.inline.clean.*;
|
|
||||||
import org.jetbrains.kotlin.js.inline.context.FunctionContext;
|
|
||||||
import org.jetbrains.kotlin.js.inline.context.InliningContext;
|
|
||||||
import org.jetbrains.kotlin.js.inline.context.NamingContext;
|
|
||||||
import org.jetbrains.kotlin.js.inline.util.*;
|
|
||||||
import org.jetbrains.kotlin.js.translate.expression.InlineMetadata;
|
|
||||||
import org.jetbrains.kotlin.resolve.inline.InlineStrategy;
|
|
||||||
|
|
||||||
import java.util.*;
|
|
||||||
import java.util.function.Function;
|
|
||||||
import java.util.stream.Collectors;
|
|
||||||
import java.util.stream.Stream;
|
|
||||||
|
|
||||||
import static org.jetbrains.kotlin.js.inline.util.CollectUtilsKt.getImportTag;
|
|
||||||
import static org.jetbrains.kotlin.js.inline.util.CollectionUtilsKt.IdentitySet;
|
|
||||||
import static org.jetbrains.kotlin.js.translate.declaration.InlineCoroutineUtilKt.transformSpecialFunctionsToCoroutineMetadata;
|
|
||||||
import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.flattenStatement;
|
|
||||||
import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.pureFqn;
|
|
||||||
|
|
||||||
public class JsInliner extends JsVisitorWithContextImpl {
|
|
||||||
|
|
||||||
private final JsConfig config;
|
|
||||||
private final Map<JsName, FunctionWithWrapper> functions;
|
|
||||||
private final Set<JsFunction> namedFunctionsSet;
|
|
||||||
private final Map<String, FunctionWithWrapper> accessors;
|
|
||||||
private final Stack<JsInliningContext> inliningContexts = new Stack<>();
|
|
||||||
private final Set<JsFunction> processedFunctions = CollectionUtilsKt.IdentitySet();
|
|
||||||
private final Set<JsFunction> inProcessFunctions = CollectionUtilsKt.IdentitySet();
|
|
||||||
private final FunctionReader functionReader;
|
|
||||||
private final DiagnosticSink trace;
|
|
||||||
private Map<String, JsName> existingImports = new HashMap<>();
|
|
||||||
private JsContext<JsStatement> statementContextForInline;
|
|
||||||
private final Map<JsBlock, FunctionWithWrapper> functionsByWrapperNodes = new HashMap<>();
|
|
||||||
private final Map<JsFunction, FunctionWithWrapper> functionsByFunctionNodes = new HashMap<>();
|
|
||||||
|
|
||||||
// these are needed for error reporting, when inliner detects cycle
|
|
||||||
private final Stack<JsFunction> namedFunctionsStack = new Stack<>();
|
|
||||||
private final LinkedList<JsCallInfo> inlineCallInfos = new LinkedList<>();
|
|
||||||
private final Function1<JsNode, Boolean> canBeExtractedByInliner =
|
|
||||||
node -> node instanceof JsInvocation && hasToBeInlined((JsInvocation) node);
|
|
||||||
private int inlineFunctionDepth;
|
|
||||||
|
|
||||||
private final Map<JsWrapperKey, Map<JsName, JsNameRef>> replacementsInducedByWrappers = new HashMap<>();
|
|
||||||
|
|
||||||
private final Map<JsName, String> inverseNameBindings;
|
|
||||||
|
|
||||||
private Map<JsName, String> existingNameBindings = new HashMap<>();
|
|
||||||
|
|
||||||
private final List<JsNameBinding> additionalNameBindings = new ArrayList<>();
|
|
||||||
|
|
||||||
private final Set<JsName> inlinedModuleAliases = new HashSet<>();
|
|
||||||
|
|
||||||
public static void process(
|
|
||||||
@NotNull JsConfig.Reporter reporter,
|
|
||||||
@NotNull JsConfig config,
|
|
||||||
@NotNull DiagnosticSink trace,
|
|
||||||
@NotNull JsName currentModuleName,
|
|
||||||
@NotNull List<JsProgramFragment> fragments,
|
|
||||||
@NotNull List<JsProgramFragment> fragmentsToProcess,
|
|
||||||
@NotNull List<JsStatement> importStatements
|
|
||||||
) {
|
|
||||||
Map<JsName, FunctionWithWrapper> functions = CollectUtilsKt.collectNamedFunctionsAndWrappers(fragments);
|
|
||||||
Map<String, FunctionWithWrapper> accessors = CollectUtilsKt.collectAccessors(fragments);
|
|
||||||
Map<JsName, String> inverseNameBindings = CollectUtilsKt.collectNameBindings(fragments);
|
|
||||||
|
|
||||||
DummyAccessorInvocationTransformer accessorInvocationTransformer = new DummyAccessorInvocationTransformer();
|
|
||||||
for (JsProgramFragment fragment : fragmentsToProcess) {
|
|
||||||
accessorInvocationTransformer.accept(fragment.getDeclarationBlock());
|
|
||||||
accessorInvocationTransformer.accept(fragment.getInitializerBlock());
|
|
||||||
}
|
|
||||||
FunctionReader functionReader = new FunctionReader(reporter, config, currentModuleName, fragments);
|
|
||||||
JsInliner inliner = new JsInliner(config, functions, accessors, inverseNameBindings, functionReader, trace);
|
|
||||||
|
|
||||||
for (JsStatement statement : importStatements) {
|
|
||||||
inliner.processImportStatement(statement);
|
|
||||||
}
|
|
||||||
|
|
||||||
Map<JsName, JsImportedModule> moduleMap = fillModuleMap(buildModuleMap(fragments), fragmentsToProcess);
|
|
||||||
|
|
||||||
for (JsProgramFragment fragment : fragmentsToProcess) {
|
|
||||||
inliner.existingImports.clear();
|
|
||||||
inliner.additionalNameBindings.clear();
|
|
||||||
inliner.inlinedModuleAliases.clear();
|
|
||||||
inliner.existingNameBindings = CollectUtilsKt.collectNameBindings(Collections.singletonList(fragment));
|
|
||||||
|
|
||||||
inliner.acceptStatement(fragment.getDeclarationBlock());
|
|
||||||
// Mostly for the sake of post-processor
|
|
||||||
// TODO are inline function marked with @Test possible?
|
|
||||||
if (fragment.getTests() != null) {
|
|
||||||
inliner.acceptStatement(fragment.getTests());
|
|
||||||
}
|
|
||||||
|
|
||||||
// There can be inlined function in top-level initializers, we need to optimize them as well
|
|
||||||
JsFunction fakeInitFunction = new JsFunction(JsDynamicScope.INSTANCE, fragment.getInitializerBlock(), "");
|
|
||||||
JsGlobalBlock initWrapper = new JsGlobalBlock();
|
|
||||||
initWrapper.getStatements().add(new JsExpressionStatement(fakeInitFunction));
|
|
||||||
inliner.accept(initWrapper);
|
|
||||||
initWrapper.getStatements().remove(initWrapper.getStatements().size() - 1);
|
|
||||||
|
|
||||||
fragment.getInitializerBlock().getStatements().addAll(0, initWrapper.getStatements());
|
|
||||||
fragment.getNameBindings().addAll(inliner.additionalNameBindings);
|
|
||||||
inliner.addInlinedModules(fragment, moduleMap);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (JsProgramFragment fragment : fragmentsToProcess) {
|
|
||||||
JsBlock block = new JsBlock(fragment.getDeclarationBlock(), fragment.getInitializerBlock(), fragment.getExportBlock());
|
|
||||||
RemoveUnusedImportsKt.removeUnusedImports(block);
|
|
||||||
SimplifyWrappedFunctionsKt.simplifyWrappedFunctions(block);
|
|
||||||
RemoveUnusedFunctionDefinitionsKt.removeUnusedFunctionDefinitions(block, CollectUtilsKt.collectNamedFunctions(block));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void addInlinedModules(JsProgramFragment fragment, Map<JsName, JsImportedModule> moduleMap) {
|
|
||||||
Set<JsName> localMap = buildModuleMap(Collections.singletonList(fragment)).keySet();
|
|
||||||
for (JsName inlinedModuleName : inlinedModuleAliases) {
|
|
||||||
if (!localMap.contains(inlinedModuleName)) {
|
|
||||||
fragment.getImportedModules().add(moduleMap.get(inlinedModuleName));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private static Map<JsName, JsImportedModule> buildModuleMap(List<JsProgramFragment> fragments) {
|
|
||||||
return fillModuleMap(new HashMap<>(), fragments);
|
|
||||||
}
|
|
||||||
|
|
||||||
private static Map<JsName, JsImportedModule> fillModuleMap(Map<JsName, JsImportedModule> map, List<JsProgramFragment> fragments) {
|
|
||||||
for (JsProgramFragment fragment : fragments) {
|
|
||||||
for (JsImportedModule module : fragment.getImportedModules()) {
|
|
||||||
map.put(module.getInternalName(), module);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return map;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
private JsInliner(
|
|
||||||
@NotNull JsConfig config,
|
|
||||||
@NotNull Map<JsName, FunctionWithWrapper> functions,
|
|
||||||
@NotNull Map<String, FunctionWithWrapper> accessors,
|
|
||||||
@NotNull Map<JsName, String> inverseNameBindings,
|
|
||||||
@NotNull FunctionReader functionReader,
|
|
||||||
@NotNull DiagnosticSink trace
|
|
||||||
) {
|
|
||||||
this.config = config;
|
|
||||||
this.functions = functions;
|
|
||||||
this.namedFunctionsSet = IdentitySet();
|
|
||||||
for (FunctionWithWrapper functionWithWrapper : functions.values()) {
|
|
||||||
namedFunctionsSet.add(functionWithWrapper.getFunction());
|
|
||||||
}
|
|
||||||
this.accessors = accessors;
|
|
||||||
this.inverseNameBindings = inverseNameBindings;
|
|
||||||
this.functionReader = functionReader;
|
|
||||||
this.trace = trace;
|
|
||||||
|
|
||||||
Stream.concat(functions.values().stream(), accessors.values().stream())
|
|
||||||
.forEach(f -> {
|
|
||||||
functionsByFunctionNodes.put(f.getFunction(), f);
|
|
||||||
if (f.getWrapperBody() != null) {
|
|
||||||
functionsByWrapperNodes.put(f.getWrapperBody(), f);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
private void processImportStatement(JsStatement statement) {
|
|
||||||
if (statement instanceof JsVars) {
|
|
||||||
JsVars jsVars = (JsVars) statement;
|
|
||||||
String tag = getImportTag(jsVars);
|
|
||||||
if (tag != null) {
|
|
||||||
existingImports.put(tag, jsVars.getVars().get(0).getName());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public boolean visit(@NotNull JsFunction function, @NotNull JsContext context) {
|
|
||||||
FunctionWithWrapper functionWithWrapper = functionsByFunctionNodes.get(function);
|
|
||||||
if (functionWithWrapper != null) {
|
|
||||||
visit(functionWithWrapper);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (statementContextForInline == null) {
|
|
||||||
statementContextForInline = getLastStatementLevelContext();
|
|
||||||
startFunction(function);
|
|
||||||
boolean result = super.visit(function, context);
|
|
||||||
statementContextForInline = null;
|
|
||||||
return result;
|
|
||||||
} else {
|
|
||||||
startFunction(function);
|
|
||||||
return super.visit(function, context);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void endVisit(@NotNull JsFunction function, @NotNull JsContext context) {
|
|
||||||
super.endVisit(function, context);
|
|
||||||
if (!functionsByFunctionNodes.containsKey(function)) {
|
|
||||||
endFunction(function);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void startFunction(@NotNull JsFunction function) {
|
|
||||||
inliningContexts.push(new JsInliningContext(statementContextForInline));
|
|
||||||
|
|
||||||
assert !inProcessFunctions.contains(function): "Inliner has revisited function";
|
|
||||||
inProcessFunctions.add(function);
|
|
||||||
|
|
||||||
if (namedFunctionsSet.contains(function)) {
|
|
||||||
namedFunctionsStack.push(function);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void endFunction(@NotNull JsFunction function) {
|
|
||||||
NamingUtilsKt.refreshLabelNames(function.getBody(), function.getScope());
|
|
||||||
|
|
||||||
RemoveUnusedLocalFunctionDeclarationsKt.removeUnusedLocalFunctionDeclarations(function);
|
|
||||||
processedFunctions.add(function);
|
|
||||||
|
|
||||||
new FunctionPostProcessor(function).apply();
|
|
||||||
|
|
||||||
assert inProcessFunctions.contains(function);
|
|
||||||
inProcessFunctions.remove(function);
|
|
||||||
|
|
||||||
inliningContexts.pop();
|
|
||||||
|
|
||||||
if (!namedFunctionsStack.empty() && namedFunctionsStack.peek() == function) {
|
|
||||||
namedFunctionsStack.pop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public boolean visit(@NotNull JsBlock x, @NotNull JsContext ctx) {
|
|
||||||
FunctionWithWrapper functionWithWrapper = functionsByWrapperNodes.get(x);
|
|
||||||
if (functionWithWrapper != null) {
|
|
||||||
visit(functionWithWrapper);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
return super.visit(x, ctx);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void visit(@NotNull FunctionWithWrapper functionWithWrapper) {
|
|
||||||
JsContext<JsStatement> oldContextForInline = statementContextForInline;
|
|
||||||
Map<String, JsName> oldExistingImports = existingImports;
|
|
||||||
int oldInlineFunctionDepth = inlineFunctionDepth;
|
|
||||||
|
|
||||||
ListContext<JsStatement> innerContext = new ListContext<>();
|
|
||||||
|
|
||||||
JsBlock wrapperBody = functionWithWrapper.getWrapperBody();
|
|
||||||
List<JsStatement> statements = null;
|
|
||||||
if (wrapperBody != null) {
|
|
||||||
existingImports = new HashMap<>();
|
|
||||||
statementContexts.push(innerContext);
|
|
||||||
statementContextForInline = innerContext;
|
|
||||||
inlineFunctionDepth++;
|
|
||||||
|
|
||||||
for (JsStatement statement : wrapperBody.getStatements()) {
|
|
||||||
processImportStatement(statement);
|
|
||||||
}
|
|
||||||
assert functionWithWrapper.getWrapperBody() != null;
|
|
||||||
statements = functionWithWrapper.getWrapperBody().getStatements();
|
|
||||||
if (!statements.isEmpty() && statements.get(statements.size() - 1) instanceof JsReturn) {
|
|
||||||
statements = statements.subList(0, statements.size() - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
innerContext.traverse(statements);
|
|
||||||
statementContexts.pop();
|
|
||||||
} else {
|
|
||||||
if (statementContextForInline == null) statementContextForInline = getLastStatementLevelContext();
|
|
||||||
}
|
|
||||||
|
|
||||||
startFunction(functionWithWrapper.getFunction());
|
|
||||||
|
|
||||||
JsBlock block = new JsBlock(functionWithWrapper.getFunction().getBody());
|
|
||||||
innerContext.traverse(block.getStatements());
|
|
||||||
functionWithWrapper.getFunction().getBody().traverse(this, innerContext);
|
|
||||||
|
|
||||||
endFunction(functionWithWrapper.getFunction());
|
|
||||||
|
|
||||||
if (statements != null) {
|
|
||||||
statements.addAll(block.getStatements().subList(0, block.getStatements().size() - 1));
|
|
||||||
}
|
|
||||||
|
|
||||||
statementContextForInline = oldContextForInline;
|
|
||||||
existingImports = oldExistingImports;
|
|
||||||
inlineFunctionDepth = oldInlineFunctionDepth;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public boolean visit(@NotNull JsInvocation call, @NotNull JsContext context) {
|
|
||||||
if (!hasToBeInlined(call)) return true;
|
|
||||||
|
|
||||||
JsFunction containingFunction = getCurrentNamedFunction();
|
|
||||||
|
|
||||||
if (containingFunction != null) {
|
|
||||||
inlineCallInfos.add(new JsCallInfo(call, containingFunction));
|
|
||||||
}
|
|
||||||
|
|
||||||
FunctionWithWrapper definition = getFunctionContext().getFunctionDefinition(call);
|
|
||||||
|
|
||||||
if (inProcessFunctions.contains(definition.getFunction())) {
|
|
||||||
reportInlineCycle(call, definition.getFunction());
|
|
||||||
}
|
|
||||||
else if (!processedFunctions.contains(definition.getFunction())) {
|
|
||||||
for (int i = 0; i < call.getArguments().size(); ++i) {
|
|
||||||
JsExpression argument = call.getArguments().get(i);
|
|
||||||
call.getArguments().set(i, accept(argument));
|
|
||||||
}
|
|
||||||
visit(definition);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void endVisit(@NotNull JsInvocation x, @NotNull JsContext ctx) {
|
|
||||||
if (hasToBeInlined(x)) {
|
|
||||||
@SuppressWarnings("unchecked")
|
|
||||||
JsContext<JsNode> context = (JsContext) ctx;
|
|
||||||
inline(x, context);
|
|
||||||
}
|
|
||||||
|
|
||||||
JsCallInfo lastCallInfo = null;
|
|
||||||
|
|
||||||
if (!inlineCallInfos.isEmpty()) {
|
|
||||||
lastCallInfo = inlineCallInfos.getLast();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (lastCallInfo != null && lastCallInfo.call == x) {
|
|
||||||
inlineCallInfos.removeLast();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void endVisit(@NotNull JsExpressionStatement x, @NotNull JsContext ctx) {
|
|
||||||
JsExpression e = x.getExpression();
|
|
||||||
if (e instanceof JsBinaryOperation) {
|
|
||||||
JsBinaryOperation binOp = (JsBinaryOperation) e;
|
|
||||||
if (binOp.getOperator() == JsBinaryOperator.ASG) {
|
|
||||||
JsExpression argument2 = binOp.getArg2();
|
|
||||||
if (argument2 != null) {
|
|
||||||
JsFunction splitSuspendInlineFunction = splitExportedSuspendInlineFunctionDeclarations(argument2);
|
|
||||||
if (splitSuspendInlineFunction != null) {
|
|
||||||
binOp.setArg2(splitSuspendInlineFunction);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
super.endVisit(x, ctx);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void endVisit(@NotNull JsVars.JsVar x, @NotNull JsContext ctx) {
|
|
||||||
JsExpression initExpression = x.getInitExpression();
|
|
||||||
if (initExpression != null) {
|
|
||||||
JsFunction splitSuspendInlineFunction = splitExportedSuspendInlineFunctionDeclarations(initExpression);
|
|
||||||
if (splitSuspendInlineFunction != null) {
|
|
||||||
x.setInitExpression(splitSuspendInlineFunction);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Nullable
|
|
||||||
private JsFunction splitExportedSuspendInlineFunctionDeclarations(@NotNull JsExpression expression) {
|
|
||||||
InlineMetadata inlineMetadata = InlineMetadata.decompose(expression);
|
|
||||||
if (inlineMetadata != null) {
|
|
||||||
FunctionWithWrapper functionWithWrapper = inlineMetadata.getFunction();
|
|
||||||
JsFunction originalFunction = functionWithWrapper.getFunction();
|
|
||||||
if (MetadataProperties.getCoroutineMetadata(originalFunction) != null) {
|
|
||||||
JsContext<JsStatement> statementContext = getLastStatementLevelContext();
|
|
||||||
|
|
||||||
// This function will be exported to JS
|
|
||||||
JsFunction function = originalFunction.deepCopy();
|
|
||||||
|
|
||||||
// Original function should be not be transformed into a state machine
|
|
||||||
originalFunction.setName(null);
|
|
||||||
MetadataProperties.setCoroutineMetadata(originalFunction, null);
|
|
||||||
MetadataProperties.setInlineableCoroutineBody(originalFunction, true);
|
|
||||||
if (functionWithWrapper.getWrapperBody() != null) {
|
|
||||||
// Extract local declarations
|
|
||||||
applyWrapper(functionWithWrapper.getWrapperBody(), function, originalFunction, new JsInliningContext(statementContext));
|
|
||||||
}
|
|
||||||
|
|
||||||
// Keep the `defineInlineFunction` for the inliner to find
|
|
||||||
statementContext.addNext(expression.makeStmt());
|
|
||||||
|
|
||||||
// Return the function body to be used without inlining.
|
|
||||||
return function;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
protected void doAcceptStatementList(List<JsStatement> statements) {
|
|
||||||
// at top level of js ast, contexts stack can be empty,
|
|
||||||
// but there is no inline calls anyway
|
|
||||||
if(!inliningContexts.isEmpty()) {
|
|
||||||
int i = 0;
|
|
||||||
|
|
||||||
while (i < statements.size()) {
|
|
||||||
List<JsStatement> additionalStatements =
|
|
||||||
ExpressionDecomposer.preserveEvaluationOrder(statements.get(i), canBeExtractedByInliner);
|
|
||||||
statements.addAll(i, additionalStatements);
|
|
||||||
i += additionalStatements.size() + 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
super.doAcceptStatementList(statements);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void inline(@NotNull JsInvocation call, @NotNull JsContext<JsNode> context) {
|
|
||||||
DeclarationDescriptor callDescriptor = MetadataProperties.getDescriptor(call);
|
|
||||||
if (isSuspendWithCurrentContinuation(callDescriptor,
|
|
||||||
CommonConfigurationKeysKt.getLanguageVersionSettings(config.getConfiguration()))) {
|
|
||||||
inlineSuspendWithCurrentContinuation(call, context);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
JsInliningContext inliningContext = getInliningContext();
|
|
||||||
FunctionWithWrapper functionWithWrapper = inliningContext.getFunctionContext().getFunctionDefinition(call);
|
|
||||||
|
|
||||||
// Since we could get functionWithWrapper as a simple function directly from staticRef (which always points on implementation)
|
|
||||||
// we should check if we have a known wrapper for it
|
|
||||||
if (functionsByFunctionNodes.containsKey(functionWithWrapper.getFunction())) {
|
|
||||||
functionWithWrapper = functionsByFunctionNodes.get(functionWithWrapper.getFunction());
|
|
||||||
}
|
|
||||||
|
|
||||||
JsFunction function = functionWithWrapper.getFunction().deepCopy();
|
|
||||||
function.setBody(transformSpecialFunctionsToCoroutineMetadata(function.getBody()));
|
|
||||||
if (functionWithWrapper.getWrapperBody() != null) {
|
|
||||||
applyWrapper(functionWithWrapper.getWrapperBody(), function, functionWithWrapper.getFunction(), inliningContext);
|
|
||||||
}
|
|
||||||
InlineableResult inlineableResult = FunctionInlineMutator.getInlineableCallReplacement(call, function, inliningContext);
|
|
||||||
|
|
||||||
JsStatement inlineableBody = inlineableResult.getInlineableBody();
|
|
||||||
JsExpression resultExpression = inlineableResult.getResultExpression();
|
|
||||||
JsContext<JsStatement> statementContext = inliningContext.getStatementContext();
|
|
||||||
// body of inline function can contain call to lambdas that need to be inlined
|
|
||||||
JsStatement inlineableBodyWithLambdasInlined = accept(inlineableBody);
|
|
||||||
assert inlineableBody == inlineableBodyWithLambdasInlined;
|
|
||||||
|
|
||||||
// Support non-local return from secondary constructor
|
|
||||||
// Returns from secondary constructors should return `$this` object.
|
|
||||||
JsFunction currentFunction = getCurrentNamedFunction();
|
|
||||||
if (currentFunction != null) {
|
|
||||||
JsName returnVariable = MetadataProperties.getForcedReturnVariable(currentFunction);
|
|
||||||
if (returnVariable != null) {
|
|
||||||
inlineableBody.accept(new RecursiveJsVisitor() {
|
|
||||||
@Override
|
|
||||||
public void visitReturn(@NotNull JsReturn x) {
|
|
||||||
x.setExpression(returnVariable.makeRef());
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
statementContext.addPrevious(flattenStatement(inlineableBody));
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Assumes, that resultExpression == null, when result is not needed.
|
|
||||||
* @see FunctionInlineMutator.isResultNeeded()
|
|
||||||
*/
|
|
||||||
if (resultExpression == null) {
|
|
||||||
statementContext.removeMe();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
resultExpression = accept(resultExpression);
|
|
||||||
MetadataProperties.setSynthetic(resultExpression, true);
|
|
||||||
context.replaceMe(resultExpression);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void applyWrapper(
|
|
||||||
@NotNull JsBlock wrapper, @NotNull JsFunction function, @NotNull JsFunction originalFunction,
|
|
||||||
@NotNull InliningContext inliningContext
|
|
||||||
) {
|
|
||||||
// Apparently we should avoid this trick when we implement fair support for crossinline
|
|
||||||
Function<JsWrapperKey, Map<JsName, JsNameRef>> replacementGen = k -> {
|
|
||||||
JsContext<JsStatement> ctx = k.context;
|
|
||||||
|
|
||||||
Map<JsName, JsNameRef> newReplacements = new HashMap<>();
|
|
||||||
|
|
||||||
List<JsStatement> copiedStatements = new ArrayList<>();
|
|
||||||
for (JsStatement statement : wrapper.getStatements()) {
|
|
||||||
if (statement instanceof JsReturn) continue;
|
|
||||||
|
|
||||||
statement = statement.deepCopy();
|
|
||||||
if (inlineFunctionDepth == 0) {
|
|
||||||
replaceExpressionsWithLocalAliases(statement);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (statement instanceof JsVars) {
|
|
||||||
JsVars jsVars = (JsVars) statement;
|
|
||||||
String tag = getImportTag(jsVars);
|
|
||||||
if (tag != null) {
|
|
||||||
JsName name = jsVars.getVars().get(0).getName();
|
|
||||||
JsName existingName = inlineFunctionDepth == 0 ? MetadataProperties.getLocalAlias(name) : null;
|
|
||||||
if (existingName == null) {
|
|
||||||
existingName = existingImports.computeIfAbsent(tag, t -> {
|
|
||||||
copiedStatements.add(jsVars);
|
|
||||||
JsName alias = JsScope.declareTemporaryName(name.getIdent());
|
|
||||||
alias.copyMetadataFrom(name);
|
|
||||||
newReplacements.put(name, pureFqn(alias, null));
|
|
||||||
return alias;
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
if (name != existingName) {
|
|
||||||
JsNameRef replacement = pureFqn(existingName, null);
|
|
||||||
newReplacements.put(name, replacement);
|
|
||||||
}
|
|
||||||
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
copiedStatements.add(statement);
|
|
||||||
}
|
|
||||||
|
|
||||||
Set<JsName> definedNames = copiedStatements.stream()
|
|
||||||
.flatMap(node -> CollectUtilsKt.collectDefinedNamesInAllScopes(node).stream())
|
|
||||||
.filter(name -> !newReplacements.containsKey(name))
|
|
||||||
.collect(Collectors.toSet());
|
|
||||||
for (JsName name : definedNames) {
|
|
||||||
JsName alias = JsScope.declareTemporaryName(name.getIdent());
|
|
||||||
alias.copyMetadataFrom(name);
|
|
||||||
JsNameRef replacement = pureFqn(alias, null);
|
|
||||||
newReplacements.put(name, replacement);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (JsStatement statement : copiedStatements) {
|
|
||||||
statement = RewriteUtilsKt.replaceNames(statement, newReplacements);
|
|
||||||
ctx.addPrevious(accept(statement));
|
|
||||||
}
|
|
||||||
|
|
||||||
for (Map.Entry<JsName, JsFunction> entry : CollectUtilsKt.collectNamedFunctions(new JsBlock(copiedStatements)).entrySet()) {
|
|
||||||
if (MetadataProperties.getStaticRef(entry.getKey()) instanceof JsFunction) {
|
|
||||||
MetadataProperties.setStaticRef(entry.getKey(), entry.getValue());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return newReplacements;
|
|
||||||
};
|
|
||||||
|
|
||||||
JsWrapperKey key = new JsWrapperKey(inliningContext.getStatementContextBeforeCurrentFunction(), originalFunction);
|
|
||||||
Map<JsName, JsNameRef> replacements = replacementsInducedByWrappers.computeIfAbsent(key, replacementGen);
|
|
||||||
|
|
||||||
RewriteUtilsKt.replaceNames(function, replacements);
|
|
||||||
|
|
||||||
// Copy nameBinding's for inlined localAlias'es
|
|
||||||
for (JsNameRef nameRef : replacements.values()) {
|
|
||||||
JsName name = nameRef.getName();
|
|
||||||
if (name != null && !existingNameBindings.containsKey(name)) {
|
|
||||||
String tag = inverseNameBindings.get(name);
|
|
||||||
if (tag != null) {
|
|
||||||
existingNameBindings.put(name, tag);
|
|
||||||
additionalNameBindings.add(new JsNameBinding(tag, name));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void replaceExpressionsWithLocalAliases(@NotNull JsStatement statement) {
|
|
||||||
new JsVisitorWithContextImpl() {
|
|
||||||
@Override
|
|
||||||
public void endVisit(@NotNull JsNameRef x, @NotNull JsContext ctx) {
|
|
||||||
replaceIfNecessary(x, ctx);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void endVisit(@NotNull JsArrayAccess x, @NotNull JsContext ctx) {
|
|
||||||
replaceIfNecessary(x, ctx);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void replaceIfNecessary(@NotNull JsExpression expression, @NotNull JsContext ctx) {
|
|
||||||
JsName alias = MetadataProperties.getLocalAlias(expression);
|
|
||||||
if (alias != null) {
|
|
||||||
@SuppressWarnings("unchecked")
|
|
||||||
JsContext<JsNode> context = (JsContext) ctx;
|
|
||||||
context.replaceMe(alias.makeRef());
|
|
||||||
inlinedModuleAliases.add(alias);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}.accept(statement);
|
|
||||||
}
|
|
||||||
|
|
||||||
private static boolean isSuspendWithCurrentContinuation(
|
|
||||||
@Nullable DeclarationDescriptor descriptor,
|
|
||||||
@NotNull LanguageVersionSettings languageVersionSettings
|
|
||||||
) {
|
|
||||||
if (!(descriptor instanceof FunctionDescriptor)) return false;
|
|
||||||
return CommonCoroutineCodegenUtilKt.isBuiltInSuspendCoroutineUninterceptedOrReturn(
|
|
||||||
(FunctionDescriptor) descriptor.getOriginal(), languageVersionSettings
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void inlineSuspendWithCurrentContinuation(@NotNull JsInvocation call, @NotNull JsContext<JsNode> context) {
|
|
||||||
JsExpression lambda = call.getArguments().get(0);
|
|
||||||
JsExpression continuationArg = call.getArguments().get(call.getArguments().size() - 1);
|
|
||||||
|
|
||||||
JsInvocation invocation = new JsInvocation(lambda, continuationArg);
|
|
||||||
MetadataProperties.setSuspend(invocation, true);
|
|
||||||
context.replaceMe(accept(invocation));
|
|
||||||
}
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
private JsInliningContext getInliningContext() {
|
|
||||||
return inliningContexts.peek();
|
|
||||||
}
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
private FunctionContext getFunctionContext() {
|
|
||||||
return getInliningContext().getFunctionContext();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Nullable
|
|
||||||
private JsFunction getCurrentNamedFunction() {
|
|
||||||
if (namedFunctionsStack.empty()) return null;
|
|
||||||
return namedFunctionsStack.peek();
|
|
||||||
}
|
|
||||||
|
|
||||||
private void reportInlineCycle(@NotNull JsInvocation call, @NotNull JsFunction calledFunction) {
|
|
||||||
MetadataProperties.setInlineStrategy(call, InlineStrategy.NOT_INLINE);
|
|
||||||
Iterator<JsCallInfo> it = inlineCallInfos.descendingIterator();
|
|
||||||
|
|
||||||
while (it.hasNext()) {
|
|
||||||
JsCallInfo callInfo = it.next();
|
|
||||||
PsiElement psiElement = MetadataProperties.getPsiElement(callInfo.call);
|
|
||||||
|
|
||||||
CallableDescriptor descriptor = MetadataProperties.getDescriptor(callInfo.call);
|
|
||||||
if (psiElement != null && descriptor != null) {
|
|
||||||
trace.report(Errors.INLINE_CALL_CYCLE.on(psiElement, descriptor));
|
|
||||||
}
|
|
||||||
|
|
||||||
if (callInfo.containingFunction == calledFunction) {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private boolean hasToBeInlined(@NotNull JsInvocation call) {
|
|
||||||
InlineStrategy strategy = MetadataProperties.getInlineStrategy(call);
|
|
||||||
if (strategy == null || !strategy.isInline()) return false;
|
|
||||||
|
|
||||||
return getFunctionContext().hasFunctionDefinition(call);
|
|
||||||
}
|
|
||||||
|
|
||||||
private class JsInliningContext implements InliningContext {
|
|
||||||
private final FunctionContext functionContext;
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
private final JsContext<JsStatement> statementContextBeforeCurrentFunction;
|
|
||||||
|
|
||||||
JsInliningContext(@NotNull JsContext<JsStatement> statementContextBeforeCurrentFunction) {
|
|
||||||
functionContext = new FunctionContext(functionReader, config) {
|
|
||||||
@Nullable
|
|
||||||
@Override
|
|
||||||
protected FunctionWithWrapper lookUpStaticFunction(@Nullable JsName functionName) {
|
|
||||||
return functions.get(functionName);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Nullable
|
|
||||||
@Override
|
|
||||||
protected FunctionWithWrapper lookUpStaticFunctionByTag(@NotNull String functionTag) {
|
|
||||||
return accessors.get(functionTag);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
this.statementContextBeforeCurrentFunction = statementContextBeforeCurrentFunction;
|
|
||||||
}
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
@Override
|
|
||||||
public NamingContext newNamingContext() {
|
|
||||||
return new NamingContext(getStatementContext());
|
|
||||||
}
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
@Override
|
|
||||||
public JsContext<JsStatement> getStatementContext() {
|
|
||||||
return getLastStatementLevelContext();
|
|
||||||
}
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
@Override
|
|
||||||
public FunctionContext getFunctionContext() {
|
|
||||||
return functionContext;
|
|
||||||
}
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
@Override
|
|
||||||
public JsContext<JsStatement> getStatementContextBeforeCurrentFunction() {
|
|
||||||
return statementContextBeforeCurrentFunction;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private static class JsCallInfo {
|
|
||||||
@NotNull
|
|
||||||
public final JsInvocation call;
|
|
||||||
|
|
||||||
@NotNull
|
|
||||||
public final JsFunction containingFunction;
|
|
||||||
|
|
||||||
private JsCallInfo(@NotNull JsInvocation call, @NotNull JsFunction function) {
|
|
||||||
this.call = call;
|
|
||||||
containingFunction = function;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static class JsWrapperKey {
|
|
||||||
final JsContext<JsStatement> context;
|
|
||||||
private final JsFunction function;
|
|
||||||
|
|
||||||
public JsWrapperKey(@NotNull JsContext<JsStatement> context, @NotNull JsFunction function) {
|
|
||||||
this.context = context;
|
|
||||||
this.function = function;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public boolean equals(Object o) {
|
|
||||||
if (this == o) return true;
|
|
||||||
if (o == null || getClass() != o.getClass()) return false;
|
|
||||||
JsWrapperKey key = (JsWrapperKey) o;
|
|
||||||
return Objects.equals(context, key.context) && Objects.equals(function, key.function);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public int hashCode() {
|
|
||||||
return Objects.hash(context, function);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -0,0 +1,653 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
|
||||||
|
* that can be found in the license/LICENSE.txt file.
|
||||||
|
*/
|
||||||
|
|
||||||
|
package org.jetbrains.kotlin.js.inline
|
||||||
|
|
||||||
|
import org.jetbrains.kotlin.backend.common.*
|
||||||
|
import org.jetbrains.kotlin.config.*
|
||||||
|
import org.jetbrains.kotlin.config.LanguageVersionSettings
|
||||||
|
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
|
||||||
|
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
|
||||||
|
import org.jetbrains.kotlin.diagnostics.DiagnosticSink
|
||||||
|
import org.jetbrains.kotlin.diagnostics.Errors
|
||||||
|
import org.jetbrains.kotlin.js.backend.ast.*
|
||||||
|
import org.jetbrains.kotlin.js.backend.ast.metadata.*
|
||||||
|
import org.jetbrains.kotlin.js.config.JsConfig
|
||||||
|
import org.jetbrains.kotlin.js.inline.clean.*
|
||||||
|
import org.jetbrains.kotlin.js.inline.context.FunctionContext
|
||||||
|
import org.jetbrains.kotlin.js.inline.context.InliningContext
|
||||||
|
import org.jetbrains.kotlin.js.inline.context.NamingContext
|
||||||
|
import org.jetbrains.kotlin.js.inline.util.*
|
||||||
|
import org.jetbrains.kotlin.js.translate.expression.InlineMetadata
|
||||||
|
import org.jetbrains.kotlin.resolve.inline.InlineStrategy
|
||||||
|
|
||||||
|
import java.util.*
|
||||||
|
|
||||||
|
import org.jetbrains.kotlin.js.inline.util.getImportTag
|
||||||
|
import org.jetbrains.kotlin.js.inline.util.IdentitySet
|
||||||
|
import org.jetbrains.kotlin.js.translate.declaration.transformSpecialFunctionsToCoroutineMetadata
|
||||||
|
import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.flattenStatement
|
||||||
|
import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.pureFqn
|
||||||
|
|
||||||
|
class JsInliner private constructor(
|
||||||
|
private val config: JsConfig,
|
||||||
|
private val functions: Map<JsName, FunctionWithWrapper>,
|
||||||
|
private val accessors: Map<String, FunctionWithWrapper>,
|
||||||
|
private val inverseNameBindings: Map<JsName, String>,
|
||||||
|
private val functionReader: FunctionReader,
|
||||||
|
private val trace: DiagnosticSink
|
||||||
|
) : JsVisitorWithContextImpl() {
|
||||||
|
private val namedFunctionsSet: MutableSet<JsFunction> = functions.values.mapTo(IdentitySet()) { it.function }
|
||||||
|
private val inliningContexts = Stack<JsInliningContext>()
|
||||||
|
private val processedFunctions = IdentitySet<JsFunction>()
|
||||||
|
private val inProcessFunctions = IdentitySet<JsFunction>()
|
||||||
|
private var existingImports: MutableMap<String, JsName> = HashMap()
|
||||||
|
private var statementContextForInline: JsContext<JsStatement>? = null
|
||||||
|
|
||||||
|
private val functionsByWrapperNodes = HashMap<JsBlock, FunctionWithWrapper>()
|
||||||
|
private val functionsByFunctionNodes = HashMap<JsFunction, FunctionWithWrapper>()
|
||||||
|
init {
|
||||||
|
(functions.values.asSequence() + accessors.values.asSequence()).forEach { f ->
|
||||||
|
functionsByFunctionNodes[f.function] = f
|
||||||
|
if (f.wrapperBody != null) {
|
||||||
|
functionsByWrapperNodes[f.wrapperBody] = f
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// these are needed for error reporting, when inliner detects cycle
|
||||||
|
private val namedFunctionsStack = Stack<JsFunction>()
|
||||||
|
private val inlineCallInfos = LinkedList<JsCallInfo>()
|
||||||
|
private val canBeExtractedByInliner: (JsNode) -> Boolean = { node -> node is JsInvocation && hasToBeInlined(node) }
|
||||||
|
private var inlineFunctionDepth: Int = 0
|
||||||
|
|
||||||
|
private val replacementsInducedByWrappers = HashMap<JsWrapperKey, Map<JsName, JsNameRef>>()
|
||||||
|
|
||||||
|
private var existingNameBindings: MutableMap<JsName, String> = HashMap()
|
||||||
|
|
||||||
|
private val additionalNameBindings = ArrayList<JsNameBinding>()
|
||||||
|
|
||||||
|
private val inlinedModuleAliases = HashSet<JsName>()
|
||||||
|
|
||||||
|
private val inliningContext: JsInliningContext
|
||||||
|
get() = inliningContexts.peek()
|
||||||
|
|
||||||
|
private val functionContext: FunctionContext
|
||||||
|
get() = inliningContext.functionContext
|
||||||
|
|
||||||
|
private val currentNamedFunction: JsFunction?
|
||||||
|
get() = if (namedFunctionsStack.empty()) null else namedFunctionsStack.peek()
|
||||||
|
|
||||||
|
private fun addInlinedModules(fragment: JsProgramFragment, moduleMap: Map<JsName, JsImportedModule>) {
|
||||||
|
val localMap = buildModuleMap(listOf(fragment)).keys
|
||||||
|
for (inlinedModuleName in inlinedModuleAliases) {
|
||||||
|
if (!localMap.contains(inlinedModuleName)) {
|
||||||
|
fragment.importedModules.add(moduleMap[inlinedModuleName]!!)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun processImportStatement(statement: JsStatement) {
|
||||||
|
if (statement is JsVars) {
|
||||||
|
val tag = getImportTag(statement)
|
||||||
|
if (tag != null) {
|
||||||
|
existingImports[tag] = statement.vars[0].name
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun visit(function: JsFunction, context: JsContext<*>): Boolean {
|
||||||
|
val functionWithWrapper = functionsByFunctionNodes[function]
|
||||||
|
if (functionWithWrapper != null) {
|
||||||
|
visit(functionWithWrapper)
|
||||||
|
return false
|
||||||
|
} else {
|
||||||
|
if (statementContextForInline == null) {
|
||||||
|
statementContextForInline = lastStatementLevelContext
|
||||||
|
startFunction(function)
|
||||||
|
val result = super.visit(function, context)
|
||||||
|
statementContextForInline = null
|
||||||
|
return result
|
||||||
|
} else {
|
||||||
|
startFunction(function)
|
||||||
|
return super.visit(function, context)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun endVisit(function: JsFunction, context: JsContext<*>) {
|
||||||
|
super.endVisit(function, context)
|
||||||
|
if (!functionsByFunctionNodes.containsKey(function)) {
|
||||||
|
endFunction(function)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun startFunction(function: JsFunction) {
|
||||||
|
inliningContexts.push(JsInliningContext(statementContextForInline!!))
|
||||||
|
|
||||||
|
assert(!inProcessFunctions.contains(function)) { "Inliner has revisited function" }
|
||||||
|
inProcessFunctions.add(function)
|
||||||
|
|
||||||
|
if (namedFunctionsSet.contains(function)) {
|
||||||
|
namedFunctionsStack.push(function)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun endFunction(function: JsFunction) {
|
||||||
|
refreshLabelNames(function.body, function.scope)
|
||||||
|
|
||||||
|
removeUnusedLocalFunctionDeclarations(function)
|
||||||
|
processedFunctions.add(function)
|
||||||
|
|
||||||
|
FunctionPostProcessor(function).apply()
|
||||||
|
|
||||||
|
assert(inProcessFunctions.contains(function))
|
||||||
|
inProcessFunctions.remove(function)
|
||||||
|
|
||||||
|
inliningContexts.pop()
|
||||||
|
|
||||||
|
if (!namedFunctionsStack.empty() && namedFunctionsStack.peek() == function) {
|
||||||
|
namedFunctionsStack.pop()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun visit(x: JsBlock, ctx: JsContext<*>): Boolean {
|
||||||
|
val functionWithWrapper = functionsByWrapperNodes[x]
|
||||||
|
if (functionWithWrapper != null) {
|
||||||
|
visit(functionWithWrapper)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return super.visit(x, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun visit(functionWithWrapper: FunctionWithWrapper) {
|
||||||
|
val oldContextForInline = statementContextForInline
|
||||||
|
val oldExistingImports = existingImports
|
||||||
|
val oldInlineFunctionDepth = inlineFunctionDepth
|
||||||
|
|
||||||
|
val innerContext = ListContext<JsStatement>()
|
||||||
|
|
||||||
|
val wrapperBody = functionWithWrapper.wrapperBody
|
||||||
|
var statements: MutableList<JsStatement>? = null
|
||||||
|
if (wrapperBody != null) {
|
||||||
|
existingImports = HashMap()
|
||||||
|
statementContexts.push(innerContext)
|
||||||
|
statementContextForInline = innerContext
|
||||||
|
inlineFunctionDepth++
|
||||||
|
|
||||||
|
for (statement in wrapperBody.statements) {
|
||||||
|
processImportStatement(statement)
|
||||||
|
}
|
||||||
|
statements = wrapperBody.statements
|
||||||
|
if (!statements.isEmpty() && statements[statements.size - 1] is JsReturn) {
|
||||||
|
statements = statements.subList(0, statements.size - 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
innerContext.traverse(statements)
|
||||||
|
statementContexts.pop()
|
||||||
|
} else {
|
||||||
|
if (statementContextForInline == null) statementContextForInline = lastStatementLevelContext
|
||||||
|
}
|
||||||
|
|
||||||
|
startFunction(functionWithWrapper.function)
|
||||||
|
|
||||||
|
val block = JsBlock(functionWithWrapper.function.body)
|
||||||
|
innerContext.traverse(block.statements)
|
||||||
|
functionWithWrapper.function.body.traverse(this, innerContext)
|
||||||
|
|
||||||
|
endFunction(functionWithWrapper.function)
|
||||||
|
|
||||||
|
statements?.addAll(block.statements.subList(0, block.statements.size - 1))
|
||||||
|
|
||||||
|
statementContextForInline = oldContextForInline
|
||||||
|
existingImports = oldExistingImports
|
||||||
|
inlineFunctionDepth = oldInlineFunctionDepth
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun visit(call: JsInvocation, context: JsContext<*>): Boolean {
|
||||||
|
if (!hasToBeInlined(call)) return true
|
||||||
|
|
||||||
|
val containingFunction = currentNamedFunction
|
||||||
|
|
||||||
|
if (containingFunction != null) {
|
||||||
|
inlineCallInfos.add(JsCallInfo(call, containingFunction))
|
||||||
|
}
|
||||||
|
|
||||||
|
val definition = functionContext.getFunctionDefinition(call)
|
||||||
|
|
||||||
|
if (inProcessFunctions.contains(definition.function)) {
|
||||||
|
reportInlineCycle(call, definition.function)
|
||||||
|
} else if (!processedFunctions.contains(definition.function)) {
|
||||||
|
for (i in 0 until call.arguments.size) {
|
||||||
|
val argument = call.arguments[i]
|
||||||
|
call.arguments[i] = accept(argument)
|
||||||
|
}
|
||||||
|
visit(definition)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun endVisit(x: JsInvocation, ctx: JsContext<JsNode>) {
|
||||||
|
if (hasToBeInlined(x)) {
|
||||||
|
inline(x, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
var lastCallInfo: JsCallInfo? = null
|
||||||
|
|
||||||
|
if (!inlineCallInfos.isEmpty()) {
|
||||||
|
lastCallInfo = inlineCallInfos.last
|
||||||
|
}
|
||||||
|
|
||||||
|
if (lastCallInfo != null && lastCallInfo.call == x) {
|
||||||
|
inlineCallInfos.removeLast()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun endVisit(x: JsExpressionStatement, ctx: JsContext<*>) {
|
||||||
|
val e = x.expression
|
||||||
|
if (e is JsBinaryOperation) {
|
||||||
|
if (e.operator == JsBinaryOperator.ASG) {
|
||||||
|
e.arg2?.let { argument2 ->
|
||||||
|
val splitSuspendInlineFunction = splitExportedSuspendInlineFunctionDeclarations(argument2)
|
||||||
|
if (splitSuspendInlineFunction != null) {
|
||||||
|
e.arg2 = splitSuspendInlineFunction
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
super.endVisit(x, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun endVisit(x: JsVars.JsVar, ctx: JsContext<*>) {
|
||||||
|
val initExpression = x.initExpression ?: return
|
||||||
|
|
||||||
|
val splitSuspendInlineFunction = splitExportedSuspendInlineFunctionDeclarations(initExpression)
|
||||||
|
if (splitSuspendInlineFunction != null) {
|
||||||
|
x.initExpression = splitSuspendInlineFunction
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun splitExportedSuspendInlineFunctionDeclarations(expression: JsExpression): JsFunction? {
|
||||||
|
val inlineMetadata = InlineMetadata.decompose(expression)
|
||||||
|
if (inlineMetadata != null) {
|
||||||
|
val (originalFunction, wrapperBody) = inlineMetadata.function
|
||||||
|
if (originalFunction.coroutineMetadata != null) {
|
||||||
|
val statementContext = lastStatementLevelContext
|
||||||
|
|
||||||
|
// This function will be exported to JS
|
||||||
|
val function = originalFunction.deepCopy()
|
||||||
|
|
||||||
|
// Original function should be not be transformed into a state machine
|
||||||
|
originalFunction.setName(null)
|
||||||
|
originalFunction.coroutineMetadata = null
|
||||||
|
originalFunction.isInlineableCoroutineBody = true
|
||||||
|
if (wrapperBody != null) {
|
||||||
|
// Extract local declarations
|
||||||
|
applyWrapper(wrapperBody, function, originalFunction, JsInliningContext(statementContext))
|
||||||
|
}
|
||||||
|
|
||||||
|
// Keep the `defineInlineFunction` for the inliner to find
|
||||||
|
statementContext.addNext(expression.makeStmt())
|
||||||
|
|
||||||
|
// Return the function body to be used without inlining.
|
||||||
|
return function
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun doAcceptStatementList(statements: MutableList<JsStatement>) {
|
||||||
|
// at top level of js ast, contexts stack can be empty,
|
||||||
|
// but there is no inline calls anyway
|
||||||
|
if (!inliningContexts.isEmpty()) {
|
||||||
|
var i = 0
|
||||||
|
|
||||||
|
while (i < statements.size) {
|
||||||
|
val additionalStatements = ExpressionDecomposer.preserveEvaluationOrder(statements[i], canBeExtractedByInliner)
|
||||||
|
statements.addAll(i, additionalStatements)
|
||||||
|
i += additionalStatements.size + 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
super.doAcceptStatementList(statements)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun inline(call: JsInvocation, context: JsContext<JsNode>) {
|
||||||
|
val callDescriptor = call.descriptor
|
||||||
|
if (isSuspendWithCurrentContinuation(
|
||||||
|
callDescriptor,
|
||||||
|
config.configuration.languageVersionSettings
|
||||||
|
)
|
||||||
|
) {
|
||||||
|
inlineSuspendWithCurrentContinuation(call, context)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
val inliningContext = inliningContext
|
||||||
|
var functionWithWrapper = inliningContext.functionContext.getFunctionDefinition(call)
|
||||||
|
|
||||||
|
// Since we could get functionWithWrapper as a simple function directly from staticRef (which always points on implementation)
|
||||||
|
// we should check if we have a known wrapper for it
|
||||||
|
functionsByFunctionNodes[functionWithWrapper.function]?.let {
|
||||||
|
functionWithWrapper = it
|
||||||
|
}
|
||||||
|
|
||||||
|
val function = functionWithWrapper.function.deepCopy()
|
||||||
|
function.body = transformSpecialFunctionsToCoroutineMetadata(function.body)
|
||||||
|
if (functionWithWrapper.wrapperBody != null) {
|
||||||
|
applyWrapper(functionWithWrapper.wrapperBody!!, function, functionWithWrapper.function, inliningContext)
|
||||||
|
}
|
||||||
|
val inlineableResult = FunctionInlineMutator.getInlineableCallReplacement(call, function, inliningContext)
|
||||||
|
|
||||||
|
val inlineableBody = inlineableResult.inlineableBody
|
||||||
|
var resultExpression = inlineableResult.resultExpression
|
||||||
|
val statementContext = inliningContext.statementContext
|
||||||
|
// body of inline function can contain call to lambdas that need to be inlined
|
||||||
|
val inlineableBodyWithLambdasInlined = accept(inlineableBody)
|
||||||
|
assert(inlineableBody === inlineableBodyWithLambdasInlined)
|
||||||
|
|
||||||
|
// Support non-local return from secondary constructor
|
||||||
|
// Returns from secondary constructors should return `$this` object.
|
||||||
|
val currentFunction = currentNamedFunction
|
||||||
|
if (currentFunction != null) {
|
||||||
|
val returnVariable = currentFunction.forcedReturnVariable
|
||||||
|
if (returnVariable != null) {
|
||||||
|
inlineableBody.accept(object : RecursiveJsVisitor() {
|
||||||
|
override fun visitReturn(x: JsReturn) {
|
||||||
|
x.expression = returnVariable.makeRef()
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
statementContext.addPrevious(flattenStatement(inlineableBody))
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Assumes, that resultExpression == null, when result is not needed.
|
||||||
|
* @see FunctionInlineMutator.isResultNeeded()
|
||||||
|
*/
|
||||||
|
if (resultExpression == null) {
|
||||||
|
statementContext.removeMe()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
resultExpression = accept(resultExpression)
|
||||||
|
resultExpression.synthetic = true
|
||||||
|
context.replaceMe(resultExpression)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun applyWrapper(
|
||||||
|
wrapper: JsBlock, function: JsFunction, originalFunction: JsFunction,
|
||||||
|
inliningContext: InliningContext
|
||||||
|
) {
|
||||||
|
val key = JsWrapperKey(inliningContext.statementContextBeforeCurrentFunction, originalFunction)
|
||||||
|
|
||||||
|
// Apparently we should avoid this trick when we implement fair support for crossinline
|
||||||
|
val replacements = replacementsInducedByWrappers.computeIfAbsent(key) { k ->
|
||||||
|
val ctx = k.context
|
||||||
|
|
||||||
|
val newReplacements = HashMap<JsName, JsNameRef>()
|
||||||
|
|
||||||
|
val copiedStatements = ArrayList<JsStatement>()
|
||||||
|
wrapper.statements.asSequence()
|
||||||
|
.filterNot { it is JsReturn }
|
||||||
|
.map { it.deepCopy() }
|
||||||
|
.forEach { statement ->
|
||||||
|
if (inlineFunctionDepth == 0) {
|
||||||
|
replaceExpressionsWithLocalAliases(statement)
|
||||||
|
}
|
||||||
|
|
||||||
|
if (statement is JsVars) {
|
||||||
|
val tag = getImportTag(statement)
|
||||||
|
if (tag != null) {
|
||||||
|
val name = statement.vars[0].name
|
||||||
|
var existingName: JsName? = if (inlineFunctionDepth == 0) name.localAlias else null
|
||||||
|
if (existingName == null) {
|
||||||
|
existingName = existingImports.computeIfAbsent(tag) {
|
||||||
|
copiedStatements.add(statement)
|
||||||
|
val alias = JsScope.declareTemporaryName(name.ident)
|
||||||
|
alias.copyMetadataFrom(name)
|
||||||
|
newReplacements[name] = pureFqn(alias, null)
|
||||||
|
alias
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (name !== existingName) {
|
||||||
|
val replacement = pureFqn(existingName, null)
|
||||||
|
newReplacements[name] = replacement
|
||||||
|
}
|
||||||
|
|
||||||
|
return@forEach
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
copiedStatements.add(statement)
|
||||||
|
}
|
||||||
|
|
||||||
|
val definedNames = copiedStatements.asSequence()
|
||||||
|
.flatMap { node -> collectDefinedNamesInAllScopes(node).asSequence() }
|
||||||
|
.filter { name -> !newReplacements.containsKey(name) }
|
||||||
|
.toSet()
|
||||||
|
for (name in definedNames) {
|
||||||
|
val alias = JsScope.declareTemporaryName(name.ident)
|
||||||
|
alias.copyMetadataFrom(name)
|
||||||
|
val replacement = pureFqn(alias, null)
|
||||||
|
newReplacements[name] = replacement
|
||||||
|
}
|
||||||
|
|
||||||
|
for (statement in copiedStatements) {
|
||||||
|
ctx.addPrevious(accept(replaceNames(statement, newReplacements)))
|
||||||
|
}
|
||||||
|
|
||||||
|
for ((key, value) in collectNamedFunctions(JsBlock(copiedStatements))) {
|
||||||
|
if (key.staticRef is JsFunction) {
|
||||||
|
key.staticRef = value
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
newReplacements
|
||||||
|
}
|
||||||
|
|
||||||
|
replaceNames(function, replacements)
|
||||||
|
|
||||||
|
// Copy nameBinding's for inlined localAlias'es
|
||||||
|
for (nameRef in replacements.values) {
|
||||||
|
val name = nameRef.name
|
||||||
|
if (name != null && !existingNameBindings.containsKey(name)) {
|
||||||
|
val tag = inverseNameBindings[name]
|
||||||
|
if (tag != null) {
|
||||||
|
existingNameBindings[name] = tag
|
||||||
|
additionalNameBindings.add(JsNameBinding(tag, name))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun replaceExpressionsWithLocalAliases(statement: JsStatement) {
|
||||||
|
object : JsVisitorWithContextImpl() {
|
||||||
|
override fun endVisit(x: JsNameRef, ctx: JsContext<JsNode>) {
|
||||||
|
replaceIfNecessary(x, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun endVisit(x: JsArrayAccess, ctx: JsContext<JsNode>) {
|
||||||
|
replaceIfNecessary(x, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun replaceIfNecessary(expression: JsExpression, ctx: JsContext<JsNode>) {
|
||||||
|
val alias = expression.localAlias
|
||||||
|
if (alias != null) {
|
||||||
|
ctx.replaceMe(alias.makeRef())
|
||||||
|
inlinedModuleAliases.add(alias)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}.accept(statement)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun inlineSuspendWithCurrentContinuation(call: JsInvocation, context: JsContext<JsNode>) {
|
||||||
|
val lambda = call.arguments[0]
|
||||||
|
val continuationArg = call.arguments[call.arguments.size - 1]
|
||||||
|
|
||||||
|
val invocation = JsInvocation(lambda, continuationArg)
|
||||||
|
invocation.isSuspend = true
|
||||||
|
context.replaceMe(accept(invocation))
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun reportInlineCycle(call: JsInvocation, calledFunction: JsFunction) {
|
||||||
|
call.inlineStrategy = InlineStrategy.NOT_INLINE
|
||||||
|
val it = inlineCallInfos.descendingIterator()
|
||||||
|
|
||||||
|
while (it.hasNext()) {
|
||||||
|
val callInfo = it.next()
|
||||||
|
val psiElement = callInfo.call.psiElement
|
||||||
|
|
||||||
|
val descriptor = callInfo.call.descriptor
|
||||||
|
if (psiElement != null && descriptor != null) {
|
||||||
|
trace.report(Errors.INLINE_CALL_CYCLE.on(psiElement, descriptor))
|
||||||
|
}
|
||||||
|
|
||||||
|
if (callInfo.containingFunction == calledFunction) {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun hasToBeInlined(call: JsInvocation): Boolean {
|
||||||
|
val strategy = call.inlineStrategy
|
||||||
|
return if (strategy == null || !strategy.isInline) false else functionContext.hasFunctionDefinition(call)
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
private inner class JsInliningContext internal constructor(override val statementContextBeforeCurrentFunction: JsContext<JsStatement>) :
|
||||||
|
InliningContext {
|
||||||
|
override val functionContext: FunctionContext
|
||||||
|
|
||||||
|
override val statementContext: JsContext<JsStatement>
|
||||||
|
get() = lastStatementLevelContext
|
||||||
|
|
||||||
|
init {
|
||||||
|
functionContext = object : FunctionContext(functionReader, config) {
|
||||||
|
override fun lookUpStaticFunction(functionName: JsName?): FunctionWithWrapper? {
|
||||||
|
return functions[functionName]
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun lookUpStaticFunctionByTag(functionTag: String): FunctionWithWrapper? {
|
||||||
|
return accessors[functionTag]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun newNamingContext(): NamingContext {
|
||||||
|
return NamingContext(statementContext)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class JsCallInfo(val call: JsInvocation, val containingFunction: JsFunction)
|
||||||
|
|
||||||
|
internal class JsWrapperKey(val context: JsContext<JsStatement>, private val function: JsFunction) {
|
||||||
|
|
||||||
|
override fun equals(o: Any?): Boolean {
|
||||||
|
if (this === o) return true
|
||||||
|
if (o == null || javaClass != o.javaClass) return false
|
||||||
|
val key = o as JsWrapperKey?
|
||||||
|
return context == key!!.context && function == key.function
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun hashCode(): Int {
|
||||||
|
return Objects.hash(context, function)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
|
||||||
|
fun process(
|
||||||
|
reporter: JsConfig.Reporter,
|
||||||
|
config: JsConfig,
|
||||||
|
trace: DiagnosticSink,
|
||||||
|
currentModuleName: JsName,
|
||||||
|
fragments: List<JsProgramFragment>,
|
||||||
|
fragmentsToProcess: List<JsProgramFragment>,
|
||||||
|
importStatements: List<JsStatement>
|
||||||
|
) {
|
||||||
|
val functions = collectNamedFunctionsAndWrappers(fragments)
|
||||||
|
val accessors = collectAccessors(fragments)
|
||||||
|
val inverseNameBindings = collectNameBindings(fragments)
|
||||||
|
|
||||||
|
val accessorInvocationTransformer = DummyAccessorInvocationTransformer()
|
||||||
|
for (fragment in fragmentsToProcess) {
|
||||||
|
accessorInvocationTransformer.accept<JsGlobalBlock>(fragment.declarationBlock)
|
||||||
|
accessorInvocationTransformer.accept<JsGlobalBlock>(fragment.initializerBlock)
|
||||||
|
}
|
||||||
|
val functionReader = FunctionReader(reporter, config, currentModuleName, fragments)
|
||||||
|
val inliner = JsInliner(config, functions, accessors, inverseNameBindings, functionReader, trace)
|
||||||
|
|
||||||
|
for (statement in importStatements) {
|
||||||
|
inliner.processImportStatement(statement)
|
||||||
|
}
|
||||||
|
|
||||||
|
val moduleMap = fillModuleMap(buildModuleMap(fragments), fragmentsToProcess)
|
||||||
|
|
||||||
|
for (fragment in fragmentsToProcess) {
|
||||||
|
inliner.existingImports.clear()
|
||||||
|
inliner.additionalNameBindings.clear()
|
||||||
|
inliner.inlinedModuleAliases.clear()
|
||||||
|
inliner.existingNameBindings = collectNameBindings(listOf(fragment))
|
||||||
|
|
||||||
|
inliner.acceptStatement<JsGlobalBlock>(fragment.declarationBlock)
|
||||||
|
// Mostly for the sake of post-processor
|
||||||
|
// TODO are inline function marked with @Test possible?
|
||||||
|
if (fragment.tests != null) {
|
||||||
|
inliner.acceptStatement(fragment.tests)
|
||||||
|
}
|
||||||
|
|
||||||
|
// There can be inlined function in top-level initializers, we need to optimize them as well
|
||||||
|
val fakeInitFunction = JsFunction(JsDynamicScope, fragment.initializerBlock, "")
|
||||||
|
val initWrapper = JsGlobalBlock()
|
||||||
|
initWrapper.statements.add(JsExpressionStatement(fakeInitFunction))
|
||||||
|
inliner.accept(initWrapper)
|
||||||
|
initWrapper.statements.removeAt(initWrapper.statements.size - 1)
|
||||||
|
|
||||||
|
fragment.initializerBlock.getStatements().addAll(0, initWrapper.statements)
|
||||||
|
fragment.nameBindings.addAll(inliner.additionalNameBindings)
|
||||||
|
inliner.addInlinedModules(fragment, moduleMap)
|
||||||
|
}
|
||||||
|
|
||||||
|
for (fragment in fragmentsToProcess) {
|
||||||
|
val block = JsBlock(fragment.declarationBlock, fragment.initializerBlock, fragment.exportBlock)
|
||||||
|
removeUnusedImports(block)
|
||||||
|
simplifyWrappedFunctions(block)
|
||||||
|
removeUnusedFunctionDefinitions(block, collectNamedFunctions(block))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun buildModuleMap(fragments: List<JsProgramFragment>): MutableMap<JsName, JsImportedModule> {
|
||||||
|
return fillModuleMap(HashMap(), fragments)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun fillModuleMap(
|
||||||
|
map: MutableMap<JsName, JsImportedModule>,
|
||||||
|
fragments: List<JsProgramFragment>
|
||||||
|
): MutableMap<JsName, JsImportedModule> {
|
||||||
|
for (fragment in fragments) {
|
||||||
|
for (module in fragment.importedModules) {
|
||||||
|
map[module.internalName] = module
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return map
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun isSuspendWithCurrentContinuation(
|
||||||
|
descriptor: DeclarationDescriptor?,
|
||||||
|
languageVersionSettings: LanguageVersionSettings
|
||||||
|
): Boolean {
|
||||||
|
return (descriptor as? FunctionDescriptor)?.original?.isBuiltInSuspendCoroutineUninterceptedOrReturn(
|
||||||
|
languageVersionSettings
|
||||||
|
) ?: false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -230,7 +230,7 @@ fun collectAccessors(fragments: List<JsProgramFragment>): Map<String, FunctionWi
|
|||||||
return result
|
return result
|
||||||
}
|
}
|
||||||
|
|
||||||
fun collectNameBindings(fragments: List<JsProgramFragment>): Map<JsName, String> {
|
fun collectNameBindings(fragments: List<JsProgramFragment>): MutableMap<JsName, String> {
|
||||||
val result = mutableMapOf<JsName, String>()
|
val result = mutableMapOf<JsName, String>()
|
||||||
for (fragment in fragments) {
|
for (fragment in fragments) {
|
||||||
for (binding in fragment.nameBindings) {
|
for (binding in fragment.nameBindings) {
|
||||||
|
|||||||
Reference in New Issue
Block a user