{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-function-completion/src/components/demo/lively-whyline-plugin.js"],"names":["generateUUID","uuid","tr","babel","types","t","template","transformFromAst","traverse","traceReference","begin","statementEnd","assignmentTemplate","functionTemplate","declarationTemplate","wrapBlockTemplate","wrapValueTemplate","checkRuntime","name","manipulateOptions","opts","parserOpts","sourceType","visitor","Program","path","isVariableAccess","identifier","badKeys","parent","isBinaryExpression","isMemberExpression","computed","isUpdateExpression","includes","key","isLiteralAccess","literal","isObjectProperty","patternVisitor","enter","skipKey","push","node","skip","gatherAssignmentTargets","pattern","array","isIdentifier","forEach","isAssignmentTarget","idcounter","scopes","uid","scope","traceid","Identifier","id","isDeclaration","bindingIdentifierEquals","binding","getBinding","scopeId","Literal","VariableDeclarator","get","assignmentTargets","AssignmentExpression","Function","console","log","programast","JSON","parse","stringify","astid","window","__tr_ast_registry__","node_map","traceNodeType","TraceNode","mapToNodeType","shouldTrace","undefined","isTraced","wrapBlock","blockOrExp","message","ID","numericLiteral","BLOCK","MSG","expression","wrapValue","exp","EXP","arrayOfArgs","vars","arrayExpression","map","arg","nullLiteral","wrapAssignment","VARS","functionStart","declaratorFollowup","statementBegin","NODEID","ensureBlock","body","isBlockStatement","statements","isStatement","Error","blockNode","blockStatement","replaceWith","exit","newNode","isFor","insertBefore","insertAfter","declaration","parentPath","init","followUp","generateUid","variableDeclarator","unshiftContainer","isFunction","isCatchClause","isTryStatement","pushContainer","ASTID","stringLiteral"],"mappings":"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","file":"lively-whyline-plugin.js","sourcesContent":["import { uuid as generateUUID } from 'utils'; \nimport * as tr from 'src/components/demo/lively-whyline-tracing.js';\nexport default function (babel) {\n  const { types: t, template, transformFromAst, traverse } = babel;\n  const traceReference = '__tr__';\n  const begin = template(`${traceReference}.stmt(NODEID)`);\n  const statementEnd = template(`${traceReference}.end()`);\n  const assignmentTemplate = template(`${traceReference}.MSG(ID,() => BLOCK,() => VARS)`);\n  const functionTemplate = template(`${traceReference}.MSG(ID, VARS)`);\n  const declarationTemplate = template(`${traceReference}.MSG(ID, VARS)`);\n  const wrapBlockTemplate = template(`${traceReference}.MSG(ID,() => BLOCK)`);\n  const wrapValueTemplate = template(`${traceReference}.MSG(ID,EXP)`);\n\n  const checkRuntime = template('if (performance.now() - _tr_time > _tr_time_max) throw new Error(\"Running too long! Endless loop?\");')\n\n  return {\n    name: \"ast-transform\", // not required\n    manipulateOptions(opts, parserOpts) {\n      parserOpts.sourceType = \"module\";\n    },\n    visitor: { \n      Program(path) {\n        /*\n         * Traverse AST to add shared properties / transformations\n         */\n        function isVariableAccess(identifier) {\n          const badKeys = ['left', 'key', 'id', 'label', 'param', 'local', 'exported', 'imported', 'meta', 'property'];\n          const parent = identifier.parent;\n          if (t.isBinaryExpression(parent)\n              || (t.isMemberExpression(parent) && parent.computed)) return true;\n          if (t.isUpdateExpression(parent)\n              //|| t.isFunction(parent)\n              //|| (t.isObjectProperty(parent) && t.isObjectPattern(parent.parent))\n              //|| t.isType(parent, \"PatternLike\")\n              || badKeys.includes(identifier.key)) return false;\n          return true;\n        }\n        \n        function isLiteralAccess(literal) {\n          const badKeys = ['key', 'source'];\n          const parent = literal.parent\n          if (t.isObjectProperty(parent) && parent.computed) return true;\n          return !badKeys.includes(literal.key);\n        }\n        \n        const patternVisitor = {\n          enter(path) {\n            path.skipKey(\"decorators\");\n          },\n          'Identifier|MemberExpression': {\n            enter(path) {\n              this.push(path.node);\n              path.skip();\n            }\n          },\n          'AssignmentPattern': {\n            enter(path) {\n              path.skipKey(\"right\");\n            }\n          },\n          'ObjectProperty': {\n            enter(path) {\n              path.skipKey(\"key\");\n            }\n          }\n        }\n        \n        function gatherAssignmentTargets(pattern, array) {\n          if (t.isIdentifier(pattern.node) || t.isMemberExpression(pattern.node)) {\n            array.push(pattern.node);\n          } else {\n            pattern.traverse(patternVisitor, array);\n          }\n          array.forEach((node) => node.isAssignmentTarget = true);\n        }\n        \n        let idcounter = 0;\n        const scopes = [];\n        \n        path.traverse({\n          enter(path) {\n            /******/\n            const uid = path.scope.uid;\n            if (!scopes[uid]) scopes[uid] = [];\n            scopes[uid].push(path.node);\n            /******/\n            path.node.traceid = idcounter++;\n          },\n          Identifier(path) {\n            const id = path.node;\n            id.isVariableAccess = !id.isAssignmentTarget && isVariableAccess(path);\n            id.isDeclaration = path.scope.bindingIdentifierEquals(path.node.name, path.node);\n            let binding = path.scope.getBinding(path.node.name);\n            path.node.scopeId = binding ? binding.scope.uid : null;\n          },\n          Literal(path) {\n            path.node.isLiteralAccess = isLiteralAccess(path);\n          },\n          VariableDeclarator(path) {\n            gatherAssignmentTargets(path.get(\"id\"), path.node.assignmentTargets = []);\n          },\n          AssignmentExpression(path) {\n            gatherAssignmentTargets(path.get(\"left\"), path.node.assignmentTargets = []);\n          },\n          Function(path) {\n            const assignmentTargets = path.node.assignmentTargets = [];\n            path.get(\"params\").forEach((pattern) => {\n              gatherAssignmentTargets(pattern, assignmentTargets);\n            });\n          }\n        });\n        \n        /*****/\n        console.log(scopes)\n        /*****/\n        \n        /*\n         * Create copy of original AST.\n         * This copy will remain unaffected by the later transformation.\n         * WARNING: Object identity is lost for objects referenced multiple times (e.g. assignmentTargets)\n         */\n\n        var programast = JSON.parse(JSON.stringify(path.node)); //create copy\n        programast.astid = generateUUID();\n        if (!window.__tr_ast_registry__) window.__tr_ast_registry__ = {};\n        window.__tr_ast_registry__[programast.astid] = programast;\n        \n        /*\n         * Do stuff with unchanging AST.\n         * This doesn't affect the actual transformation.\n         */\n        \n        programast.node_map = [];\n\n        traverse({\"type\": \"File\", \"program\": programast}, {\n            enter(path) {\n              let node = path.node;\n              programast.node_map[node.traceid] = node;\n              node.traceNodeType = tr.TraceNode.mapToNodeType(node);\n              node.parent = path.parent; //convencience for inspecting the resulting ast\n            }\n        })\n        \n        /*\n         * Utility functions\n         */\n        \n        function shouldTrace(path) {\n          let node = path.node\n          if ((node.traceid === undefined) || node.isTraced) {\n            return false;\n          } else {\n            return node.isTraced = true\n          }\n        }\n        \n        function wrapBlock(id, blockOrExp, message = 'exp') {\n          return wrapBlockTemplate({\n            ID: t.numericLiteral(id),\n            BLOCK: blockOrExp,\n            MSG: t.identifier(message)\n          }).expression //Or do we ever actually prefer ExpressionStatement over Expression?\n        }\n        \n        function wrapValue(id, exp, message = 'val') {\n          return wrapValueTemplate({\n            ID: t.numericLiteral(id),\n            EXP: exp,\n            MSG: t.identifier(message)\n          }).expression\n        }\n        \n        function arrayOfArgs(vars) {\n          return t.arrayExpression(vars.map((arg) => t.isIdentifier(arg) ? arg : t.nullLiteral()));\n        }\n        \n        function wrapAssignment(id, exp, vars, message='asgn') {\n          return assignmentTemplate({\n            ID: t.numericLiteral(id),\n            BLOCK: exp,\n            VARS: arrayOfArgs(vars),\n            MSG: t.identifier(message)\n          }).expression;\n        }\n        \n        function functionStart(id, vars, message='func') {\n          return functionTemplate({\n            ID: t.numericLiteral(id),\n            VARS: arrayOfArgs(vars),\n            MSG: t.identifier(message)\n          });\n        }\n        \n        function declaratorFollowup(id, vars, message='decl') {\n          return declarationTemplate({\n            ID: t.numericLiteral(id),\n            VARS: arrayOfArgs(vars),\n            MSG: t.identifier(message)\n          });\n        }\n        \n        function statementBegin(id) {\n          return begin({\n            NODEID: t.numericLiteral(id)\n          });\n        }\n        \n        function ensureBlock(body) {\n          if (!body.node) return null;\n          \n          if (body.isBlockStatement()) {\n            return body.node;\n          }\n\n          const statements = [];\n          if (body.isStatement()) {\n            statements.push(body.node);\n          } else {\n            throw new Error(\"I never thought this was even possible.\");\n          }\n          \n          const blockNode = t.blockStatement(statements);\n          body.replaceWith(blockNode);\n          return blockNode;\n        }\n        \n        /*\n         * Preprocess AST\n         */\n        \n        path.traverse({\n          'IfStatement': {\n            enter(path) {\n              ensureBlock(path.get(\"consequent\"));\n              ensureBlock(path.get(\"alternate\"));\n            }\n          },\n          'For|While|Function': {\n            enter(path) {\n              ensureBlock(path.get(\"body\"));\n            }\n          }\n        })\n        \n        /*\n         * Transform AST to include tracing\n         */\n        console.log(programast);\n        path.traverse({\n          /*enter(path) {\n            console.log(`enter ${path.node.traceid}`);\n          },\n          exit(path) {\n            console.log(`exit ${path.node.traceid}`);\n          },*/\n          'BinaryExpression|CallExpression|UnaryExpression|ObjectExpression|UpdateExpression|ArrayExpression|NewExpression|ConditionalExpression': {\n            exit(path) {\n              if (shouldTrace(path)) {\n                const newNode = wrapBlock(path.node.traceid, path);\n                path.replaceWith(newNode);\n              }\n            }\n          },\n          'AssignmentExpression': {\n            exit(path) {\n              if (shouldTrace(path)) {\n                const node = path.node;\n                const newNode = wrapAssignment(node.traceid, path, node.assignmentTargets);\n                path.replaceWith(newNode);\n              }\n            }\n          },\n          'VariableDeclaration': {\n            enter(path) {\n              if (shouldTrace(path) && !t.isFor(path.parent)) {\n                path.insertBefore(statementBegin(path.node.traceid));\n                path.insertAfter(statementEnd());\n              }\n            }\n          },\n          'VariableDeclarator': {\n            enter(path) {\n              if (shouldTrace(path)) {\n                const node = path.node;\n                const declaration = path.parentPath;\n                const init = path.get('init');\n                const newNode = wrapBlock(node.traceid, init.node || t.identifier(\"undefined\"));\n                init.replaceWith(newNode);\n                const followUp = declaratorFollowup(node.traceid, node.assignmentTargets);\n                if (!t.isFor(declaration.parent)) {\n                  declaration.insertAfter(followUp);\n                } else {\n                  const uid = t.identifier(declaration.scope.generateUid(\"decl\"));\n                  path.insertAfter(t.variableDeclarator(uid, followUp.expression));\n                }\n              }\n            }\n          },\n          'IfStatement': {\n            exit(path) {\n              if (shouldTrace(path)) {\n                path.insertBefore(statementBegin(path.node.traceid));\n                path.insertAfter(statementEnd());\n              }\n            }\n          },\n          'For|While': {\n            exit(path) {\n              if (shouldTrace(path)) {\n                path.get(\"body\").unshiftContainer(\"body\", checkRuntime());\n                path.insertBefore(statementBegin(path.node.traceid));\n                path.insertAfter(statementEnd());\n              }\n            }\n          },\n          'BlockStatement': {\n            enter(path) {\n              if (shouldTrace(path)) {\n                const parent = path.parent;\n                if (t.isFunction(parent) || t.isCatchClause(parent) || t.isTryStatement(parent)) return;\n                console.log(path.node);\n                path.unshiftContainer(\"body\", statementBegin(path.node.traceid));\n                path.pushContainer(\"body\", statementEnd());\n              }\n            }\n          },\n          'Function': {\n            enter(path) {\n              if (shouldTrace(path)) {\n                const node = path.node;\n                const body = path.get(\"body\");\n                body.unshiftContainer(\"body\", checkRuntime());\n                body.unshiftContainer(\"body\", functionStart(node.traceid, node.assignmentTargets));\n                body.pushContainer(\"body\", statementEnd());\n              }\n            }\n          },\n          'Identifier': {\n            exit(path) {\n              const node = path.node;\n              if (shouldTrace(path) && node.isVariableAccess) {\n                const newNode = wrapValue(node.traceid, path);\n                path.replaceWith(newNode);\n              }\n            }\n          },\n          'Literal': {\n            exit(path) {\n              const node = path.node;\n              if (shouldTrace(path) && node.isLiteralAccess) {\n                const newNode = wrapValue(node.traceid, path);\n                path.replaceWith(newNode);\n              }\n            }\n          },\n          'MemberExpression': {\n            exit(path) {\n              if (shouldTrace(path) && !path.node.isAssignmentTarget) {\n                const newNode = wrapBlock(path.node.traceid, path);\n                path.replaceWith(newNode);\n              }\n            }\n          },\n          'ReturnStatement': {\n            exit(path) {\n              if (shouldTrace(path)) {\n                const arg = path.get('argument');\n                const newNode = wrapBlock(path.node.traceid, arg.node || t.identifier(\"undefined\"), 'rtrn');\n                arg.replaceWith(newNode);\n              }\n            }\n          }\n        })\n\n        path.unshiftContainer('body', template(`\n          const __tr_ast__ = window.__tr_ast_registry__[ASTID]\n\n          const ${traceReference} = new window.lively4ExecutionTrace(__tr_ast__);\n\n          const _tr_time = performance.now();\n          const _tr_time_max = 1000;\n\n    \t  \t__tr_ast__.calltrace = ${traceReference}.traceRoot\n          __tr_ast__.executionTrace = ${traceReference}\n\n    \t  \twindow.__tr_last_ast__ = __tr_ast__`)({ASTID: t.stringLiteral(programast.astid)}));\n      } \n    }\n  };\n}"]}