{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-drawio/src/client/reactive/babel-plugin-active-expression-rewriting/index.js"],"names":["isVariable","AEXPR_IDENTIFIER_NAME","GET_MEMBER","GET_AND_CALL_MEMBER","TRACE_MEMBER","SET_MEMBER_BY_OPERATORS","DELETE_MEMBER","SET_LOCAL","GET_LOCAL","SET_GLOBAL","GET_GLOBAL","IGNORE_STRING","IGNORE_INDICATOR","Symbol","FLAG_GENERATED_SCOPE_OBJECT","FLAG_SHOULD_NOT_REWRITE_IDENTIFIER","FLAG_SHOULD_NOT_REWRITE_MEMBER_EXPRESSION","FLAG_SHOULD_NOT_REWRITE_CALL_EXPRESSION","FLAG_SHOULD_NOT_REWRITE_ASSIGNMENT_EXPRESSION","markMemberToNotBeRewritten","path","types","t","template","traverse","getPropertyFromMemberExpression","node","computed","property","stringLiteral","name","GENERATED_FUNCTION","isGenerated","findParent","p","isFunctionDeclaration","tNonRewritable","Proxy","get","target","prop","receiver","args","nonRewritableIdentifier","identifier","GENERATED_IMPORT_IDENTIFIER","addCustomTemplate","file","declar","declarations","addImport","checkExpressionAnalysisMode","ifStatement","memberExpression","expressionStatement","isInForLoopIterator","isInForLoop","find","parentPath","isForStatement","includes","parentKey","isForInStatement","isForOfStatement","isInDesctructuringAssignment","patternParent","isPattern","inVarDefinition","isVariableDeclarator","inAssignment","isAssignmentExpression","inParams","isFunction","pre","visitor","Program","enter","state","shouldTransform","opts","enableViaDirective","Directive","value","getIdentifierForExplicitScopeObject","parentWithScope","bindings","scope","scopeName","Object","keys","key","id","uniqueIdentifier","generateUidIdentifier","push","kind","init","objectExpression","maybeWrapInStatement","wrapInReturnStatement","isStatement","isExpression","expressionNode","returnStatement","loc","console","error","wrapPropertyOfPath","oldBody","oldBodyNode","isBlockStatement","Array","newBodyNode","blockStatement","isArrowFunctionExpression","replaceWith","BlockParent","isProgram","isSwitchStatement","body","warn","IfStatement","SwitchCase","UnaryExpression","operator","argument","isMemberExpression","callExpression","object","array","isArrayExpression","length","expr","arrowFunctionExpression","UpdateExpression","prefix","isIdentifier","assignment","assignmentExpression","numericLiteral","reverseOperator","binaryExpression","Identifier","logIdentifier","msg","log","start","line","isCallExpression","parent","hasBinding","isExportSpecifier","isMetaProperty","isAssignmentPattern","isUpdateExpression","isFunctionExpression","isImportDefaultSpecifier","isCatchClause","isContinueStatement","isObjectProperty","isClassDeclaration","isClassExpression","isClassMethod","isImportSpecifier","isObjectMethod","isRestElement","par","hasOwnBinding","insertBefore","isReferencedIdentifier","AssignmentExpression","left","right","valueToReturn","valueForAExpr","sequenceExpression","conditionalExpression","booleanLiteral","unaryExpression","MemberExpression","isBindExpression","isSuper","CallExpression","callee","isDuplicatableMemberExpression","memberPath","objectPath","isSimpleObject","isThisExpression","isComputedProperty","propertyPath","isSimpleProperty","isStringLiteral","getTraceIdentifierForSimpleObject","thisExpression","buildCodeFrameError","traceIdentifier","arrayExpression","arguments"],"mappings":"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","file":"index.js","sourcesContent":["import { isVariable } from './utils.js';\n\nconst AEXPR_IDENTIFIER_NAME = 'aexpr';\n\nconst GET_MEMBER = 'getMember';\nconst GET_AND_CALL_MEMBER = 'getAndCallMember';\n\nconst TRACE_MEMBER = 'traceMember';\n\nconst SET_MEMBER_BY_OPERATORS = {\n  '=': 'setMember',\n  '+=': 'setMemberAddition',\n  '-=': 'setMemberSubtraction',\n  '*=': 'setMemberMultiplication',\n  '/=': 'setMemberDivision',\n  '%=': 'setMemberRemainder',\n  '**=': 'setMemberExponentiation',\n  '<<=': 'setMemberLeftShift',\n  '>>=': 'setMemberRightShift',\n  '>>>=': 'setMemberUnsignedRightShift',\n  '&=': 'setMemberBitwiseAND',\n  '^=': 'setMemberBitwiseXOR',\n  '|=': 'setMemberBitwiseOR'\n};\n\nconst DELETE_MEMBER = 'deleteMember';\n\nconst SET_LOCAL = 'setLocal';\nconst GET_LOCAL = 'getLocal';\n\nconst SET_GLOBAL = 'setGlobal';\nconst GET_GLOBAL = 'getGlobal';\n\nconst IGNORE_STRING = 'aexpr ignore';\nconst IGNORE_INDICATOR = Symbol('aexpr ignore');\n\n// TODO: use multiple flag for indication of generated content, marking explicit scopes, etc.\nconst FLAG_GENERATED_SCOPE_OBJECT = Symbol('FLAG: generated scope object');\nconst FLAG_SHOULD_NOT_REWRITE_IDENTIFIER = Symbol('FLAG: should not rewrite identifier');\nconst FLAG_SHOULD_NOT_REWRITE_MEMBER_EXPRESSION = Symbol('FLAG: should not rewrite member expression');\nconst FLAG_SHOULD_NOT_REWRITE_CALL_EXPRESSION = Symbol('FLAG: should not rewrite call expression');\nconst FLAG_SHOULD_NOT_REWRITE_ASSIGNMENT_EXPRESSION = Symbol('FLAG: should not rewrite assignment expression');\n\nfunction markMemberToNotBeRewritten(path) {\n  path[FLAG_SHOULD_NOT_REWRITE_MEMBER_EXPRESSION] = true;\n  return path;\n}\n\nexport default function({ types: t, template, traverse }) {\n\n  function getPropertyFromMemberExpression(node) {\n    // We are looking for MemberExpressions, which have two distinct incarnations:\n    // 1. we have a computed MemberExpression like a[b], with the property being an Expression\n    // 2. a non-computed MemberExpression like a.b, with the property being an Identifier\n    return node.computed ?\n      // We can easily deal with the first case by replacing the MemberExpression with a call\n      node.property :\n      // In the second case, we introduce a StringLiteral matching the Identifier\n      t.stringLiteral(node.property.name);\n  }\n\n  const GENERATED_FUNCTION = Symbol(\"generated function\");\n\n  function isGenerated(path) {\n    return path.findParent(p => t.isFunctionDeclaration(p.node) && p.node[GENERATED_FUNCTION])\n  }\n  \n  const tNonRewritable = new Proxy({}, {\n    get(target, prop, receiver) {\n      return (...args) => {\n        const node = t[prop](...args);\n        // --> #TODO: should use a common 'doNotRewriteNode' and 'doNotRewriteSubtree' flags\n        node[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n        return node;\n      };\n    }\n  });\n\n  function nonRewritableIdentifier(name) {\n    return tNonRewritable.identifier(name);\n    const node = t.identifier(name);\n    node[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n    return node;\n  }\n\n  const GENERATED_IMPORT_IDENTIFIER = Symbol(\"generated import identifier\");\n\n  //     let customTemplates = {};\n  //     customTemplates[SET_MEMBER] = template(`\n  //   (function(obj, prop, operator, val) {\n  //     return obj[prop] = val;\n  //   });\n  // `);\n  //\n  //     customTemplates[GET_MEMBER] = template(`\n  //   (function(obj, prop) {\n  //     return obj[prop];\n  //   });\n  // `);\n  //\n  //     customTemplates[GET_AND_CALL_MEMBER] = template(`\n  //   (function(obj, prop, args) {\n  //     return obj[prop](...args)\n  //   });\n  // `);\n  //\n  //     customTemplates[AEXPR_IDENTIFIER_NAME] = template(`\n  //   (function(expr) {\n  //     return { onChange(cb) {}};\n  //   });\n  // `);\n\n  function addCustomTemplate(file, name) {\n    let declar = file.declarations[name];\n    if (declar) return declar;\n\n    let identifier = file.declarations[name] = file.addImport(\"active-expression-rewriting\", name, name);\n    identifier[GENERATED_IMPORT_IDENTIFIER] = true;\n    return identifier;\n\n    // let ref = customTemplates[name];\n    // console.log(file.addImport(\"active-expression-rewriting\", \"aexpr\"));\n    // let uid = file.declarations[name] = file.scope.generateUidIdentifier(name);\n    //\n    // ref = ref().expression;\n    // ref[GENERATED_FUNCTION] = true;\n    //\n    // if (t.isFunctionExpression(ref) && !ref.id) {\n    //     ref.body._compact = true;\n    //     ref._generated = true;\n    //     ref.id = uid;\n    //     ref.type = \"FunctionDeclaration\";\n    //     file.path.unshiftContainer(\"body\", ref);\n    // } else {\n    //     ref._compact = true;\n    //     file.scope.push({\n    //         id: uid,\n    //         init: ref,\n    //         unique: true\n    //     });\n    // }\n    //\n    // return uid;\n  }\n  \n  // #TODO: add global flag for expression analysis mode\n  function checkExpressionAnalysisMode(node) {\n    return t.ifStatement(\n      markMemberToNotBeRewritten(t.memberExpression(\n        nonRewritableIdentifier('self'),\n        nonRewritableIdentifier('__expressionAnalysisMode__')\n      )),\n      t.expressionStatement(node)\n      // ,t.unaryExpression(\"void\", t.numericLiteral(0), true)\n    );\n  }\n\n  function isInForLoopIterator(path) {\n    const isInForLoop = path.find(p => {\n      if(!p.parentPath) return false;\n      if(p.parentPath.isForStatement() && ['init', 'test', 'update'].includes(p.parentKey)) return true;\n      if(p.parentPath.isForInStatement() && p.parentKey === 'left') return true;\n      if(p.parentPath.isForOfStatement() && p.parentKey === 'left') return true;\n      return false;\n    })\n    return !!isInForLoop;\n  }\n  \n  function isInDesctructuringAssignment(path) {\n    const patternParent = path.find(p => {\n      if(!p.isPattern()) { return false; }\n      if(!p.parentPath) { return false; }\n      \n      const inVarDefinition = p.parentPath.isVariableDeclarator() && p.parentKey === 'id';\n      const inAssignment = p.parentPath.isAssignmentExpression() && p.parentKey === 'left';\n      const inParams = p.parentPath.isFunction() && p.parentKey === 'params';\n      return inVarDefinition || inAssignment || inParams;\n    });\n    return !!patternParent;\n  }\n  \n  return {\n    pre(file) {\n      //console.log(\"fff\", file, traverse);\n    },\n    visitor: {\n      Program: {\n        enter(path, state) {\n          //console.log(\"file\", path, state);\n          // console.log(\"AEXPR\", state && state.file && state.file.log && state.file.log.filename);\n          //console.log(\"AEXPR\", path, state, state && state.opts && state.opts.enableViaDirective)\n          let shouldTransform = true;\n          if(state.opts.enableViaDirective) {\n            shouldTransform = false;\n            path.traverse({\n              Directive(path) {\n                if(path.get(\"value\").node.value === \"enable aexpr\") {\n                  shouldTransform = true;\n                }\n              }\n            });\n          }\n          \n          if (!shouldTransform) {\n            return;\n          }\n\n          function getIdentifierForExplicitScopeObject(parentWithScope) {\n            let bindings = parentWithScope.scope.bindings;\n            let scopeName = Object.keys(bindings).find(key => {\n              return bindings[key].path &&\n                bindings[key].path.node &&\n                bindings[key].path.node.id &&\n                bindings[key].path.node.id[FLAG_GENERATED_SCOPE_OBJECT] // should actually be IS_EXPLICIT_SCOPE_OBJECT\n            });\n\n            let uniqueIdentifier;\n            if (scopeName) {\n              uniqueIdentifier = t.identifier(scopeName);\n            } else {\n              uniqueIdentifier = parentWithScope.scope.generateUidIdentifier('scope');\n              uniqueIdentifier[FLAG_GENERATED_SCOPE_OBJECT] = true;\n\n              parentWithScope.scope.push({\n                kind: 'let',\n                id: uniqueIdentifier,\n                init: t.objectExpression([])\n              });\n            }\n            uniqueIdentifier[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n            return uniqueIdentifier;\n          }\n\n          // ------------- ensureBlock -------------\n          const maybeWrapInStatement = (node, wrapInReturnStatement) => {\n            if(t.isStatement(node)) {\n              return node;\n            } else if(t.isExpression(node)) {\n              // wrap in return statement if we have an arrow function: () => 42 -> () => { return 42; }\n              const expressionNode = wrapInReturnStatement ? t.returnStatement(node) : t.expressionStatement(node);\n              expressionNode.loc = node.loc;\n              return expressionNode;\n            } else {\n              console.error(\"Tried to wrap something unknown:\", node);\n              return node;\n            }\n          }\n          const wrapPropertyOfPath = (path, property) => {\n            const oldBody = path.get(property);\n            const oldBodyNode = path.node[property];\n            if(!oldBodyNode) {\n              return;\n            }\n            if(oldBody.isBlockStatement && oldBody.isBlockStatement()) {\n              // This is already a block\n              return;\n            } else if(oldBody instanceof Array) {\n              const newBodyNode = t.blockStatement(oldBodyNode);\n              path.node[property] = [newBodyNode];\n            } else {\n              const newBodyNode = t.blockStatement([maybeWrapInStatement(oldBodyNode, path.isArrowFunctionExpression())]);\n              oldBody.replaceWith(newBodyNode);\n            }\n            return path;\n          }\n          path.traverse({\n            BlockParent(path) {\n              if(path.isProgram() || path.isBlockStatement() || path.isSwitchStatement()) {\n                return;\n              }\n              if(!path.node.body) {\n                console.warn(\"A BlockParent without body: \", path);\n              }\n\n              wrapPropertyOfPath(path, \"body\");\n            },\n            IfStatement(path) {\n              for(let property of [\"consequent\", \"alternate\"]) {\n                wrapPropertyOfPath(path, property);\n              }\n            },\n            SwitchCase(path) {\n              wrapPropertyOfPath(path, \"consequent\");\n            }\n          });\n          \n          path.traverse({\n\n            UnaryExpression(path) {\n              if(isInForLoopIterator(path)) { return; }\n              if(isInDesctructuringAssignment(path)) { return; }\n\n              // handle delete operator\n              if(path.node.operator === 'delete') {\n                const argument = path.get('argument');\n                if(argument.isMemberExpression()) {\n                  path.replaceWith(\n                    t.callExpression(\n                      addCustomTemplate(state.file, DELETE_MEMBER), [\n                        argument.node.object,\n                        getPropertyFromMemberExpression(argument.node)\n                      ]\n                    )\n                  );\n                }\n                return;\n              }\n              \n              // transform ~[expr] notation to _aexpr(() => expr)\n              if(path.node.operator !== '~') return;\n              const array = path.get('argument');\n              if(!array.isArrayExpression()) return;\n              if(array.get('elements').length !== 1) return;\n              const expr = array.get('elements')[0];\n              \n              path.replaceWith(\n                t.callExpression(\n                  addCustomTemplate(state.file, AEXPR_IDENTIFIER_NAME), [\n                    t.arrowFunctionExpression(\n                      [], expr.node\n                    )\n                    // path.node.left.object,\n                    // getPropertyFromMemberExpression(path.node.left),\n                    // //t.stringLiteral(path.node.operator),\n                    // path.node.right\n                  ]\n                )\n              );\n            },\n\n            UpdateExpression(path) {\n              const operator = path.node.operator;\n              const prefix = path.node.prefix;\n              const argument = path.get('argument');\n              if(isInForLoopIterator(path)) { return; }\n              if(isInDesctructuringAssignment(path)) { return; }\n\n              if(argument.isMemberExpression() || argument.isIdentifier()) {\n                \n                // ++v -> v += 1\n                let assignment = t.assignmentExpression(\n                  operator[0] + '=',\n                  argument.node,\n                  t.numericLiteral(1),\n                )\n                \n                if(!prefix) {\n                  // need to modify result for postfix operators\n                  // v++ -> (v += 1) - 1\n                  const reverseOperator = operator[0] === '+' ? '-' : '+';\n                  assignment = t.binaryExpression(\n                    reverseOperator,\n                    assignment,\n                    t.numericLiteral(1)\n                  )\n                }\n                \n                path.replaceWith(assignment);\n              }\n            },\n\n            Identifier(path) {\n              //console.log(path.node.name);\n\n              function logIdentifier(msg, path) {\n                console.log(msg, path.node.name, path.node.loc ? path.node.loc.start.line : '');\n              }\n\n              if (path.node[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER]) {\n                return;\n              }\n\n              // Check for a call to undeclared aexpr:\n              if (\n                t.isCallExpression(path.parent) &&\n                path.node.name === AEXPR_IDENTIFIER_NAME &&\n                !path.scope.hasBinding(AEXPR_IDENTIFIER_NAME)\n              ) {\n                //logIdentifier(\"call to aexpr\", path);\n                path.replaceWith(\n                  addCustomTemplate(state.file, AEXPR_IDENTIFIER_NAME)\n                );\n                return;\n              }\n\n              // property local of ExportStatement\n              if (\n                t.isExportSpecifier(path.parent) &&\n                path.parentKey === 'local'\n              ) {\n                return;\n              }\n\n              if (\n                // TODO: is there a general way to exclude non-variables?\n                isVariable(path) &&\n                !(t.isMetaProperty(path.parent)) &&\n                !(t.isForInStatement(path.parent) && path.parentKey === 'left') &&\n                !(t.isAssignmentPattern(path.parent) && path.parentKey === 'left') &&\n                !(t.isUpdateExpression(path.parent)) &&\n                !(t.isFunctionExpression(path.parent) && path.parentKey === 'id') &&\n                !(t.isImportDefaultSpecifier(path.parent) && path.parentKey === 'local') &&\n                !(t.isCatchClause(path.parent) && path.parentKey === 'param') &&\n                !(t.isContinueStatement(path.parent) && path.parentKey === 'label') &&\n                !t.isObjectProperty(path.parent) &&\n                !t.isClassDeclaration(path.parent) &&\n                !t.isClassExpression(path.parent) &&\n                !t.isClassMethod(path.parent) &&\n                !t.isImportSpecifier(path.parent) &&\n                !t.isObjectMethod(path.parent) &&\n                !t.isVariableDeclarator(path.parent) &&\n                !t.isFunctionDeclaration(path.parent) &&\n                !(t.isArrowFunctionExpression(path.parent) && path.parentKey === 'params') &&\n                !(t.isExportSpecifier(path.parent) && path.parentKey === 'exported') &&\n                !(t.isFunctionExpression(path.parent) && path.parentKey === 'params') &&\n                !t.isRestElement(path.parent) &&\n                (!t.isAssignmentExpression(path.parent) || !(path.parentKey === 'left'))\n              ) {\n                if(isInForLoopIterator(path)) { return; }\n                if(isInDesctructuringAssignment(path)) { return; }\n  \n                if (path.scope.hasBinding(path.node.name)) {\n                  //logIdentifier('get local var', path)\n                  path.node[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n\n                  let parentWithScope = path.findParent(par =>\n                    par.scope.hasOwnBinding(path.node.name)\n                  );\n                  if (parentWithScope) {\n                    //function printParents(path) {\n                    //  let result = [path.type];\n                    //  path.findParent(p => {\n                    //    result.push(p.type);\n                    //    return false;\n                    //  });\n                    //  console.log(result.join('\\n\\r'))\n                    //}\n                    //printParents(path);\n                    //const node = path.parentPath.parentPath;\n                    //                                    const statement = path.getStatementParent();\n                    //                                      console.warn(statement, statement.type);\n                    //node.unshiftContainer('body', t.expressionStatement(t.stringLiteral(\"HELLO!?\")));\n                    // lively.openInspector(statement);\n                    //statement.insertBefore(t.expressionStatement(t.stringLiteral(\"WORLD\")))\n                    //printParents(path.getStatementParent())\n                    //printParents(path.getFunctionParent())\n                    //path.getFunctionParent().ensureBlock();\n                    //path.insertBefore(t.expressionStatement(t.stringLiteral(\"Because I'm easy come, easy go.\")));\n\n                    path.insertBefore(\n                      checkExpressionAnalysisMode(\n                        t.callExpression(\n                          addCustomTemplate(state.file, GET_LOCAL), [\n                            getIdentifierForExplicitScopeObject(parentWithScope),\n                            t.stringLiteral(path.node.name),\n                            nonRewritableIdentifier(path.node.name)\n                          ]\n                        )\n                      )\n                    );\n                  }\n                } else {\n                  //logIdentifier('get global var', path);\n                  path.node[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n\n                  path.insertBefore(\n                    checkExpressionAnalysisMode(\n                      t.callExpression(\n                        addCustomTemplate(state.file, GET_GLOBAL), [t.stringLiteral(path.node.name)]\n                      )\n                    )\n                  );\n                }\n                return;\n              }\n\n              //logIdentifier('others', path);\n              return;\n\n              if (path.node[GENERATED_IMPORT_IDENTIFIER]) {\n                logIdentifier('Generated Import Identifier', path)\n                return;\n              }\n\n              // global?\n              //if (!path.isReferencedIdentifier()) {\n              //logIdentifier('is no referenced identifier', path);\n              //return;\n              //}\n\n              // The identifier should not reference a variable in current scope\n              if (path.scope.hasBinding(path.node.name)) {\n                logIdentifier('Binding for ', path);\n                return;\n              }\n\n              logIdentifier('Unexpected Case', path);\n\n              return;\n\n              //if(RESERVED_IDENTIFIERS.includes(path.node.name)) { return; }\n\n              if (t.isClassDeclaration(path.parent)) {\n                console.log(\"classDecl\", path.node.name);\n                return;\n              }\n\n              if (t.isClassMethod(path.parent)) {\n                console.log(\"classMethod\", path.node.name);\n                return;\n              }\n\n              if (t.isObjectMethod(path.parent)) {\n                console.log(\"objectMethod\", path.node.name);\n                return;\n              }\n              if (t.isVariableDeclarator(path.parent)) {\n                console.log(\"varDecl\", path.node.name);\n                return;\n              }\n\n              // is this correct here?\n              // TODO: is it correct for the locals plugin?\n              if (!path.isReferencedIdentifier()) {\n                console.log(\"def\", path.node.name);\n                return;\n              }\n\n              // is locally defined variable?\n              if (path.scope.hasBinding(path.node.name)) {\n                console.log(\"local\", path.node.name);\n              } else {\n                // we have a global\n                console.log(\"global\", path.node.name);\n              }\n            },\n            AssignmentExpression(path) {\n              if(isInForLoopIterator(path)) { return; }\n              if(isInDesctructuringAssignment(path)) { return; }\n              // check, whether we assign to a member (no support for pattern right now)\n              if (t.isMemberExpression(path.node.left) &&\n                !isGenerated(path) &&\n                SET_MEMBER_BY_OPERATORS[path.node.operator]\n              ) {\n\n                //state.file.addImport\n                path.replaceWith(\n                  t.callExpression(\n                    addCustomTemplate(state.file, SET_MEMBER_BY_OPERATORS[path.node.operator]), [\n                      path.node.left.object,\n                      getPropertyFromMemberExpression(path.node.left),\n                      //t.stringLiteral(path.node.operator),\n                      path.node.right\n                    ]\n                  )\n                );\n              }\n\n              if (t.isIdentifier(path.node.left) &&\n                !path.node[FLAG_SHOULD_NOT_REWRITE_ASSIGNMENT_EXPRESSION]) {\n                if (path.scope.hasBinding(path.node.left.name)) {\n                  //console.log('set local', path.node.left.name);\n                  path.node[FLAG_SHOULD_NOT_REWRITE_ASSIGNMENT_EXPRESSION] = true;\n\n                  const parentWithScope = path.findParent(par =>\n                    par.scope.hasOwnBinding(path.node.left.name)\n                  );\n                  if (parentWithScope) {\n                    let valueToReturn = t.identifier(path.node.left.name);\n                    valueToReturn[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n                    let valueForAExpr = t.identifier(path.node.left.name);\n                    valueForAExpr[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n                    // #TODO: turn into .insertAfter\n                    // caution: doing so automatically inserts a temporary variable (_temp), which is in turn rewritten!\n                    //path.insertAfter(\n                    //t.ifStatement(\n                    //  t.booleanLiteral(true),\n                    //  t.expressionStatement(\n                    //    t.callExpression(\n                    //      addCustomTemplate(state.file, SET_LOCAL),\n                    //      [\n                    //        getIdentifierForExplicitScopeObject(parentWithScope),\n                    //        t.stringLiteral(path.node.left.name)\n                    //      ]\n                    //    )\n                    //  )\n                    //)\n                    //);\n                    path.replaceWith(\n                      t.sequenceExpression([\n                        path.node,\n                        t.conditionalExpression(\n                          t.booleanLiteral(true),\n                          t.callExpression(\n                            addCustomTemplate(state.file, SET_LOCAL), [\n                              getIdentifierForExplicitScopeObject(parentWithScope),\n                              t.stringLiteral(path.node.left.name),\n                              valueForAExpr\n                            ]\n                          ),\n                          t.unaryExpression('void', t.numericLiteral(0))\n                        ),\n                        valueToReturn\n                      ])\n                    );\n                  }\n                } else {\n                  // global assginment\n                  //console.log('---global---', path.node.left.name);\n                  path.node[FLAG_SHOULD_NOT_REWRITE_ASSIGNMENT_EXPRESSION] = true;\n\n                  let valueToReturn = t.identifier(path.node.left.name);\n                  valueToReturn[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n                  path.replaceWith(\n                    t.sequenceExpression([\n                      path.node,\n                      t.callExpression(\n                        addCustomTemplate(state.file, SET_GLOBAL), [t.stringLiteral(path.node.left.name)]\n                      ),\n                      valueToReturn\n                    ]));\n\n                }\n              }\n\n            },\n\n            MemberExpression(path) {\n              // lval (left values) are ignored for now\n              if(path.parentPath.isCallExpression() && path.parentKey === \"callee\") { return; }\n              // #TODO: BindExpressions are ignored for now; they are static anyway ;)\n              if(path.parentPath.isBindExpression() && path.parentKey === \"callee\") { return; }\n              if (t.isAssignmentExpression(path.parent) && path.key === 'left') { return; }\n              if (t.isUpdateExpression(path.parent) && path.key === 'argument') { return; }\n              if (t.isSuper(path.node.object)) { return; }\n              if (isGenerated(path)) { return; }\n              if(isInForLoopIterator(path)) { return; }\n              if(isInDesctructuringAssignment(path)) { return; }\n              if(path.node[FLAG_SHOULD_NOT_REWRITE_MEMBER_EXPRESSION]) { return; }\n              \n              path.replaceWith(\n                t.callExpression(\n                  addCustomTemplate(state.file, GET_MEMBER), [\n                    path.node.object,\n                    getPropertyFromMemberExpression(path.node)\n                  ]\n                )\n              );\n            },\n\n            CallExpression(path) {\n              if(isGenerated(path)) { return; }\n              if(path.node.callee && t.isSuper(path.node.callee.object)) { return; }\n              if(path.node[FLAG_SHOULD_NOT_REWRITE_CALL_EXPRESSION]) { return; }\n              if(isInForLoopIterator(path)) { return; }\n              if(isInDesctructuringAssignment(path)) { return; }\n\n              // check whether we call a MemberExpression\n              if(t.isMemberExpression(path.node.callee)) {\n                function isDuplicatableMemberExpression(memberPath) {\n                  const objectPath = memberPath.get('object');\n                  const isSimpleObject = objectPath.isIdentifier() || objectPath.isThisExpression();\n                  const isComputedProperty = memberPath.node.computed;\n                  const propertyPath = memberPath.get('property');\n                  let isSimpleProperty;\n                  if(isComputedProperty) {\n                    isSimpleProperty = propertyPath.isStringLiteral() ||\n                      propertyPath.isIdentifier();\n                  } else {\n                    isSimpleProperty = propertyPath.isIdentifier();\n                  }\n                  return isSimpleObject && isSimpleProperty;\n                }\n                \n                if(isDuplicatableMemberExpression(path.get(\"callee\"))) {\n                  function getTraceIdentifierForSimpleObject(objectPath) {\n                    if(objectPath.isIdentifier()) {\n                      return nonRewritableIdentifier(objectPath.node.name);\n                    } else if(objectPath.isThisExpression()) {\n                      return t.thisExpression();\n                    } else {\n                      throw objectPath.buildCodeFrameError(\"Tried to trace a simple MemberExpression>object, but it is neither an Identifier nor a ThisExpression\");\n                    }\n                  }\n\n                  const traceIdentifier = getTraceIdentifierForSimpleObject(path.get('callee').get('object'));\n                  // break a recursive call expression when doing `(obj.fn(), obj.fn());`\n                  path.node[FLAG_SHOULD_NOT_REWRITE_CALL_EXPRESSION] = true;\n                  // insert traceMember before actual call\n                  path.insertBefore(\n                    checkExpressionAnalysisMode(\n                      t.callExpression(\n                        addCustomTemplate(state.file, TRACE_MEMBER), [\n                          traceIdentifier,\n                          getPropertyFromMemberExpression(path.node.callee)\n                        ]\n                      )\n                    )\n                  )\n                } else {\n                  path.replaceWith(\n                    t.callExpression(\n                      addCustomTemplate(state.file, GET_AND_CALL_MEMBER), [\n                        path.node.callee.object,\n                        getPropertyFromMemberExpression(path.node.callee),\n                        t.arrayExpression(path.node.arguments)\n                      ]\n                    )\n                  )\n                }\n              } else {\n                // call to a local/global variable is handled elsewhere\n                if (t.isIdentifier(path.node.callee) && true) {}\n              }\n            }\n            \n          });\n        }\n      }\n    }\n  };\n}\n"]}