@markw65/monkeyc-optimizer 1.0.18 → 1.0.21

package/build/api.cjs

@@ -132,23 +132,32 @@ function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
     const getSafety = (decl) => {
-        // enums are constant, they cant change
-        if (decl.type === "EnumStringMember")
-            return true;
-        if (decl.type === "VariableDeclarator") {
-            // constants also can't change
-            if (decl.node.kind === "const")
+        switch (decl.type) {
+            // enums are constant, they cant change
+            case "EnumStringMember":
                 return true;
-            // if decl is a local, it also can't be changed
-            // by a call to another function.
-            for (let i = 0;; i++) {
-                if (!state.stack[i] || decl.stack[i] !== state.stack[i])
-                    return false;
-                if (state.stack[i].type === "FunctionDeclaration")
+            case "VariableDeclarator": {
+                // constants also can't change
+                if (decl.node.kind === "const")
                     return true;
+                // if decl is a local, it also can't be changed
+                // by a call to another function.
+                for (let i = 0;; i++) {
+                    if (!state.stack[i] || decl.stack[i] !== state.stack[i])
+                        return false;
+                    if (state.stack[i].type === "FunctionDeclaration")
+                        return true;
+                }
             }
+            case "Identifier":
+            case "BinaryExpression":
+                // This is a parameter of the calling function.
+                // It also can't be changed during the execution
+                // of the inlined function
+                return true;
+            default:
+                return null;
         }
-        return null;
     };
     const safeArgs = [];
     let allSafe = true;
@@ -256,15 +265,32 @@ function inliningLooksUseful(func, node) {
     }
     return false;
 }
-var inliner_InlineStatus;
+var InlineStatus;
 (function (InlineStatus) {
     InlineStatus[InlineStatus["Never"] = 0] = "Never";
     InlineStatus[InlineStatus["AsExpression"] = 1] = "AsExpression";
     InlineStatus[InlineStatus["AsStatement"] = 2] = "AsStatement";
-})(inliner_InlineStatus || (inliner_InlineStatus = {}));
-function inliner_shouldInline(state, func, args) {
+})(InlineStatus || (InlineStatus = {}));
+function inlineRequested(state, func) {
+    const excludeAnnotations = (func.node.loc?.source &&
+        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
+        {};
+    if (func.node.attrs &&
+        func.node.attrs.attributes &&
+        func.node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" &&
+            (attr.argument.name === "inline" ||
+                (attr.argument.name.startsWith("inline_") &&
+                    hasProperty(excludeAnnotations, attr.argument.name.substring(7)))))) {
+        return true;
+    }
+    return false;
+}
+function inliner_shouldInline(state, func, call, context) {
+    if (state.inlining)
+        return false;
     let autoInline = false;
     let inlineAsExpression = false;
+    const args = call.arguments;
     if (func.node.body &&
         func.node.body.body.length === 1 &&
         func.node.body.body[0].type === "ReturnStatement" &&
@@ -274,39 +300,31 @@ function inliner_shouldInline(state, func, args) {
         autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
     }
     if (autoInline === 1) {
-        return inliner_InlineStatus.AsExpression;
+        return true;
     }
-    const excludeAnnotations = (func.node.loc?.source &&
-        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
-        {};
-    const inlineRequested = func.node.attrs &&
-        func.node.attrs.attrs &&
-        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
-            (attr.argument.name === "inline" ||
-                (attr.argument.name.startsWith("inline_") &&
-                    hasProperty(excludeAnnotations, attr.argument.name.substring(7)))));
-    if (autoInline || inlineRequested) {
-        return inlineAsExpression && canInline(state, func, args)
-            ? inliner_InlineStatus.AsExpression
-            : inliner_InlineStatus.AsStatement;
+    const requested = inlineRequested(state, func);
+    if (autoInline || requested) {
+        if (inlineAsExpression) {
+            if (canInline(state, func, args)) {
+                return true;
+            }
+        }
+        if (!context && requested) {
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+        }
+        return context != null;
     }
-    return inliner_InlineStatus.Never;
+    return false;
 }
 function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
-    if (!params) {
-        const safeArgs = getArgSafety(state, func, call.arguments, false);
-        params = Object.fromEntries(func.node.params.map((param, i) => {
-            const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
-                ? i
-                : -1;
-            const name = variableDeclarationName(param);
-            return [name, argnum];
-        }));
-    }
+    let failed = false;
     const pre = state.pre;
     const post = state.post;
+    state.inlining = true;
     try {
         state.pre = (node) => {
+            if (failed)
+                return [];
             node.start = call.start;
             node.end = call.end;
             node.loc = call.loc;
@@ -318,6 +336,11 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                 const { map } = locals;
                 if (!map)
                     throw new Error("No local variable map!");
+                // We still need to keep track of every local name that was
+                // already in use, but we don't want to use any of its renames.
+                // We also want to know whether a local is from the function being
+                // inlined, or the calling function, so set every element to false.
+                Object.keys(map).forEach((key) => (map[key] = false));
                 const declarations = func.node.params
                     .map((param, i) => {
                     const paramName = variableDeclarationName(param);
@@ -342,6 +365,8 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
             return result;
         };
         state.post = (node) => {
+            if (failed)
+                return post(node, state);
             let replacement = null;
             switch (node.type) {
                 case "Identifier": {
@@ -356,26 +381,34 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     }
                     replacement = fixNodeScope(state, node, func.stack);
                     if (!replacement) {
-                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                        failed = true;
+                        inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
+                        return post(node, state);
                     }
                     break;
                 }
             }
-            return post(replacement || node, state) || replacement;
+            const ret = post(replacement || node, state);
+            return ret === false || ret ? ret : replacement;
         };
-        return state.traverse(root) || null;
-    }
-    catch (ex) {
-        if (ex instanceof Error) {
-            if (ex.message.startsWith("Inliner: ")) {
-                return null;
-            }
+        let ret = state.traverse(root);
+        if (failed) {
+            return null;
         }
-        throw ex;
+        if (ret === null) {
+            ret = root;
+        }
+        if (!ret) {
+            inlineDiagnostic(state, func, call, `Internal error`);
+            return null;
+        }
+        inlineDiagnostic(state, func, call, null);
+        return ret;
     }
     finally {
         state.pre = pre;
         state.post = post;
+        delete state.inlining;
     }
 }
 function inliner_unused(expression, top) {
@@ -394,7 +427,16 @@ function inliner_unused(expression, top) {
         case "UnaryExpression":
             return inliner_unused(expression.argument);
         case "MemberExpression":
-            return inliner_unused(expression.object).concat(inliner_unused(expression.property));
+            if (expression.computed) {
+                return inliner_unused(expression.object).concat(inliner_unused(expression.property));
+            }
+            return inliner_unused(expression.object);
+        case "ArrayExpression":
+            return expression.elements.map((e) => inliner_unused(e)).flat(1);
+        case "ObjectExpression":
+            return expression.properties
+                .map((p) => inliner_unused(p.key).concat(inliner_unused(p.value)))
+                .flat(1);
     }
     return top
         ? null
@@ -402,30 +444,98 @@ function inliner_unused(expression, top) {
             {
                 type: "ExpressionStatement",
                 expression,
+                start: expression.start,
+                end: expression.end,
+                loc: expression.loc,
             },
         ];
 }
-function inlineWithArgs(state, func, call) {
+function diagnostic(state, loc, message) {
+    if (!loc || !loc.source)
+        return;
+    const source = loc.source;
+    if (!state.diagnostics)
+        state.diagnostics = {};
+    if (!hasProperty(state.diagnostics, source)) {
+        if (!message)
+            return;
+        state.diagnostics[source] = [];
+    }
+    const diags = state.diagnostics[source];
+    let index = diags.findIndex((item) => item.loc === loc);
+    if (message) {
+        if (index < 0)
+            index = diags.length;
+        diags[index] = { type: "INFO", loc, message };
+    }
+    else if (index >= 0) {
+        diags.splice(index, 1);
+    }
+}
+function inlineDiagnostic(state, func, call, message) {
+    if (inlineRequested(state, func)) {
+        diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
+    }
+}
+function inlineWithArgs(state, func, call, context) {
     if (!func.node || !func.node.body) {
         return null;
     }
     let retStmtCount = 0;
-    traverseAst(func.node.body, (node) => {
-        node.type === "ReturnStatement" && retStmtCount++;
-    });
-    if (retStmtCount > 1 ||
-        (retStmtCount === 1 &&
-            func.node.body.body.slice(-1)[0].type !== "ReturnStatement")) {
-        return null;
+    if (context.type === "ReturnStatement") {
+        const last = func.node.body.body.slice(-1)[0];
+        if (!last || last.type !== "ReturnStatement") {
+            inlineDiagnostic(state, func, call, "Function didn't end with a return statement");
+            return null;
+        }
+    }
+    else {
+        traverseAst(func.node.body, (node) => {
+            node.type === "ReturnStatement" && retStmtCount++;
+        });
+        if (retStmtCount > 1) {
+            inlineDiagnostic(state, func, call, "Function had more than one return statement");
+        }
+        else if (context.type === "AssignmentExpression" && retStmtCount !== 1) {
+            inlineDiagnostic(state, func, call, "Function did not have a return statement");
+            return null;
+        }
+        if (retStmtCount === 1) {
+            const last = func.node.body.body.slice(-1)[0];
+            if (!last ||
+                last.type !== "ReturnStatement" ||
+                (context.type === "AssignmentExpression" && !last.argument)) {
+                inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
+                return null;
+            }
+        }
     }
     const body = JSON.parse(JSON.stringify(func.node.body));
-    processInlineBody(state, func, call, body, func.node.params.length ? false : true);
-    if (retStmtCount) {
+    const safeArgs = getArgSafety(state, func, call.arguments, false);
+    const params = Object.fromEntries(func.node.params.map((param, i) => {
+        const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
+            ? i
+            : -1;
+        const name = variableDeclarationName(param);
+        return [name, argnum];
+    }));
+    if (!processInlineBody(state, func, call, body, func.node.params.length ? false : true, params)) {
+        return null;
+    }
+    diagnostic(state, call.loc, null);
+    if (context.type !== "ReturnStatement" && retStmtCount) {
         const last = body.body[body.body.length - 1];
         if (last.type != "ReturnStatement") {
             throw new Error("ReturnStatement got lost!");
         }
-        if (last.argument) {
+        if (context.type === "AssignmentExpression") {
+            context.right = last.argument;
+            body.body[body.body.length - 1] = {
+                type: "ExpressionStatement",
+                expression: context,
+            };
+        }
+        else if (last.argument) {
             const side_exprs = inliner_unused(last.argument);
             body.body.splice(body.body.length - 1, 1, ...side_exprs);
         }
@@ -435,13 +545,13 @@ function inlineWithArgs(state, func, call) {
     }
     return body;
 }
-function inliner_inlineFunction(state, func, call, inlineStatus) {
-    if (inlineStatus == inliner_InlineStatus.AsStatement) {
-        return inlineWithArgs(state, func, call);
+function inliner_inlineFunction(state, func, call, context) {
+    if (context) {
+        return inlineWithArgs(state, func, call, context);
     }
     const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
     const params = Object.fromEntries(func.node.params.map((param, i) => [variableDeclarationName(param), i]));
-    return processInlineBody(state, func, call, retArg, true, params) || retArg;
+    return processInlineBody(state, func, call, retArg, true, params);
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -456,13 +566,14 @@ function applyTypeIfNeeded(node) {
 }
 function fixNodeScope(state, lookupNode, nodeStack) {
     if (lookupNode.type === "Identifier") {
-        for (let i = state.stack.length; --i > nodeStack.length;) {
-            const si = state.stack[i];
-            if (hasProperty(si.decls, lookupNode.name)) {
-                // its a local from the inlined function.
-                // Nothing to do.
-                return lookupNode;
-            }
+        const locals = state.localsStack[state.localsStack.length - 1];
+        const { map } = locals;
+        if (!map)
+            throw new Error("No local variable map!");
+        if (hasProperty(map, lookupNode.name) && map[lookupNode.name] !== false) {
+            // map[name] !== false means its an entry that was created during inlining
+            // so its definitely one of our locals.
+            return lookupNode;
         }
     }
     const [, original] = state.lookup(lookupNode, null, nodeStack);
@@ -682,12 +793,12 @@ async function analyze(fnMap) {
         shouldExclude(node) {
             if ("attrs" in node &&
                 node.attrs &&
-                "attrs" in node.attrs &&
-                node.attrs.attrs &&
+                "attributes" in node.attrs &&
+                node.attrs.attributes &&
                 node.loc?.source) {
                 const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
                 if (excludeAnnotations) {
-                    return node.attrs.attrs.reduce((drop, attr) => {
+                    return node.attrs.attributes.elements.reduce((drop, attr) => {
                         if (attr.type != "UnaryExpression")
                             return drop;
                         if (attr.argument.type != "Identifier")
@@ -938,13 +1049,15 @@ function optimizeNode(node) {
     return null;
 }
 function evaluateFunction(func, args) {
-    if (args && args.length != func.params.length) {
+    if (!func.body || (args && args.length != func.params.length)) {
         return false;
     }
     const paramValues = args &&
         Object.fromEntries(func.params.map((p, i) => [variableDeclarationName(p), args[i]]));
     let ret = null;
-    const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
+    const body = args
+        ? JSON.parse(JSON.stringify(func.body))
+        : func.body;
     try {
         traverseAst(body, (node) => {
             switch (node.type) {
@@ -987,6 +1100,13 @@ function evaluateFunction(func, args) {
         return false;
     }
 }
+function markFunctionCalled(state, func) {
+    if (!hasProperty(state.calledFunctions, func.id.name)) {
+        state.calledFunctions[func.id.name] = [func];
+        return;
+    }
+    pushUnique(state.calledFunctions[func.id.name], func);
+}
 async function optimizeMonkeyC(fnMap) {
     const state = {
         ...(await analyze(fnMap)),
@@ -994,7 +1114,13 @@ async function optimizeMonkeyC(fnMap) {
         exposed: {},
         calledFunctions: {},
     };
-    const replace = (node, obj) => {
+    const replace = (node) => {
+        if (node === false || node === null)
+            return node;
+        const rep = state.traverse(node);
+        return rep === false || rep ? rep : node;
+    };
+    const inPlaceReplacement = (node, obj) => {
         for (const k of Object.keys(node)) {
             delete node[k];
         }
@@ -1019,7 +1145,7 @@ async function optimizeMonkeyC(fnMap) {
         if (!obj) {
             return false;
         }
-        replace(node, obj);
+        inPlaceReplacement(node, obj);
         return true;
     };
     const topLocals = () => state.localsStack[state.localsStack.length - 1];
@@ -1035,8 +1161,8 @@ async function optimizeMonkeyC(fnMap) {
         if (hasProperty(state.exposed, func.id.name))
             return true;
         if (func.attrs &&
-            func.attrs.attrs &&
-            func.attrs.attrs.some((attr) => {
+            func.attrs.attributes &&
+            func.attrs.attributes.elements.some((attr) => {
                 if (attr.type != "UnaryExpression")
                     return false;
                 if (attr.argument.type != "Identifier")
@@ -1145,7 +1271,7 @@ async function optimizeMonkeyC(fnMap) {
                 if (map) {
                     if (hasProperty(map, node.name)) {
                         const name = map[node.name];
-                        if (name !== true) {
+                        if (typeof name === "string") {
                             node.name = name;
                         }
                     }
@@ -1196,10 +1322,7 @@ async function optimizeMonkeyC(fnMap) {
                         used = checkInherited(parent, node.id.name);
                     }
                     if (used) {
-                        if (!hasProperty(state.calledFunctions, node.id.name)) {
-                            state.calledFunctions[node.id.name] = [];
-                        }
-                        state.calledFunctions[node.id.name].push(node);
+                        markFunctionCalled(state, node);
                     }
                 }
             }
@@ -1212,8 +1335,7 @@ async function optimizeMonkeyC(fnMap) {
         }
         const opt = optimizeNode(node);
         if (opt) {
-            replace(node, opt);
-            return null;
+            return replace(opt);
         }
         switch (node.type) {
             case "ConditionalExpression":
@@ -1223,7 +1345,7 @@ async function optimizeMonkeyC(fnMap) {
                     const rep = node.test.value ? node.consequent : node.alternate;
                     if (!rep)
                         return false;
-                    replace(node, rep);
+                    return replace(rep);
                 }
                 break;
             case "WhileStatement":
@@ -1236,27 +1358,50 @@ async function optimizeMonkeyC(fnMap) {
                     return node.body;
                 }
                 break;
-            case "CallExpression": {
-                const ret = optimizeCall(state, node, false);
-                if (ret) {
-                    replace(node, ret);
+            case "ReturnStatement":
+                if (node.argument && node.argument.type === "CallExpression") {
+                    return replace(optimizeCall(state, node.argument, node));
                 }
                 break;
+            case "CallExpression": {
+                return replace(optimizeCall(state, node, null));
             }
+            case "AssignmentExpression":
+                if (node.operator === "=" &&
+                    node.left.type === "Identifier" &&
+                    node.right.type === "Identifier" &&
+                    node.left.name === node.right.name) {
+                    return { type: "Literal", value: null, raw: "null" };
+                }
+                break;
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    const ret = optimizeCall(state, node.expression, true);
-                    if (ret) {
-                        if (ret.type === "BlockStatement") {
-                            return ret;
+                    return replace(optimizeCall(state, node.expression, node));
+                }
+                else if (node.expression.type === "AssignmentExpression") {
+                    if (node.expression.right.type === "CallExpression") {
+                        let ok = false;
+                        if (node.expression.left.type === "Identifier") {
+                            if (hasProperty(topLocals().map, node.expression.left.type)) {
+                                ok = true;
+                            }
+                        }
+                        if (!ok && node.expression.operator == "=") {
+                            const [, result] = state.lookup(node.expression.left);
+                            ok = result != null;
+                        }
+                        if (ok) {
+                            return replace(optimizeCall(state, node.expression.right, node.expression));
                         }
-                        node.expression = ret;
                     }
                 }
                 else {
                     const ret = unused(node.expression, true);
                     if (ret) {
-                        return ret;
+                        return ret
+                            .map(replace)
+                            .flat(1)
+                            .filter((s) => !!s);
                     }
                 }
                 break;
@@ -1266,6 +1411,11 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         collectNamespaces(f.ast, state);
     });
+    state.calledFunctions = {};
+    state.exposed = {};
+    Object.values(fnMap).forEach((f) => {
+        collectNamespaces(f.ast, state);
+    });
     delete state.pre;
     delete state.post;
     const cleanup = (node) => {
@@ -1294,19 +1444,24 @@ async function optimizeMonkeyC(fnMap) {
                 if (!node.body.members.length) {
                     if (!node.id)
                         return false;
-                    if (!node.body["enumType"]) {
+                    if (!node.body.enumType) {
                         throw new Error("Missing enumType on optimized enum");
                     }
-                    replace(node, {
+                    return {
                         type: "TypedefDeclaration",
                         id: node.id,
                         ts: {
                             type: "UnaryExpression",
-                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            argument: {
+                                type: "TypeSpecList",
+                                ts: [
+                                    node.body.enumType,
+                                ],
+                            },
                             prefix: true,
                             operator: " as",
                         },
-                    });
+                    };
                 }
                 break;
             case "VariableDeclaration": {
@@ -1341,9 +1496,12 @@ async function optimizeMonkeyC(fnMap) {
             return ret;
         });
     });
+    return state.diagnostics;
 }
-function optimizeCall(state, node, asStatement) {
-    const [name, callees] = state.lookup(node.callee);
+function optimizeCall(state, node, context) {
+    const [name, results] = state.lookup(node.callee);
+    const callees = results &&
+        results.filter((c) => c.type === "FunctionDeclaration");
     if (!callees || !callees.length) {
         const n = name ||
             ("name" in node.callee && node.callee.name) ||
@@ -1362,7 +1520,8 @@ function optimizeCall(state, node, asStatement) {
     }
     if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
         const callee = callees[0].node;
-        if (callee.optimizable &&
+        if (!context &&
+            callee.optimizable &&
             !callee.hasOverride &&
             node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
             const ret = evaluateFunction(callee, node.arguments);
@@ -1370,19 +1529,14 @@ function optimizeCall(state, node, asStatement) {
                 return ret;
             }
         }
-        const inlineStatus = shouldInline(state, callees[0], node.arguments);
-        if (inlineStatus === InlineStatus.AsExpression ||
-            (asStatement && inlineStatus === InlineStatus.AsStatement)) {
-            const ret = inlineFunction(state, callees[0], node, inlineStatus);
+        if (shouldInline(state, callees[0], node, context)) {
+            const ret = inlineFunction(state, callees[0], node, context);
             if (ret) {
                 return ret;
             }
         }
     }
-    if (!hasProperty(state.calledFunctions, name)) {
-        state.calledFunctions[name] = [];
-    }
-    callees.forEach((c) => isStateNode(c) && state.calledFunctions[name].push(c.node));
+    callees.forEach((c) => markFunctionCalled(state, c.node));
     return null;
 }
 
@@ -1914,23 +2068,14 @@ function api_traverseAst(node, pre, post) {
     return post && post(node);
 }
 function formatAst(node, monkeyCSource = null) {
-    if ("comments" in node && !monkeyCSource) {
-        // Prettier inserts comments by using the source location to
-        // find the original comment, rather than using the contents
-        // of the comment as reported by the comment nodes themselves.
-        // If all we've got is the ast, rather than the actual
-        // source code, this goes horribly wrong, so just drop all
-        // the comments.
-        delete node.comments;
-    }
     /*
      * The estree printer sometimes looks at the parent node without
      * checking that there *is* a parent node (eg it assumes all
      * BinaryExpressions have a parent node, and crashes if they don't).
-     * To avoid issues, wrap nodes in an ExpressionStatement, and
-     * then remove the added ";" from the end.
+     * To avoid issues, wrap nodes in an ParenthesizedExpression.
+     * The printer knows that parentless ParenthesizedExpressions
+     * should be ignored.
      */
-    let unwrap = false;
     switch (node.type) {
         case "Program":
         case "BlockStatement":
@@ -1938,11 +2083,10 @@ function formatAst(node, monkeyCSource = null) {
             break;
         default: {
             const e = {
-                type: "ExpressionStatement",
+                type: "ParenthesizedExpression",
                 expression: node,
             };
             node = e;
-            unwrap = true;
         }
     }
     // If we *do* have the original source, pass that in ahead of the
@@ -1950,15 +2094,11 @@ function formatAst(node, monkeyCSource = null) {
     // as the ast itself, and the printers will find what they're
     // looking for in the source.
     const source = (monkeyCSource || "") + "\n" + JSON.stringify(node);
-    const result = external_prettier_namespaceObject.format(source, {
+    return external_prettier_namespaceObject.format(source, {
         parser: "monkeyc-json",
         plugins: [(prettier_plugin_monkeyc_default())],
         endOfLine: "lf",
     });
-    if (unwrap) {
-        return result.replace(/;$/, "");
-    }
-    return result;
 }
 function handleException(state, node, exception) {
     try {