{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-RP19-4/src/client/reactive/babel-plugin-active-expression-rewriting/index.js"],"names":["isVariable","Preferences","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","babel","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","isInDestructuringAssignment","patternParent","isPattern","inVarDefinition","isVariableDeclarator","inAssignment","isAssignmentExpression","inParams","isFunction","pre","visitor","Program","enter","state","hasDirective","foundDirective","Directive","value","shouldTransform","proxyDirective","proxyPreference","inWorkspace","opts","executedIn","inFile","Error","enableViaDirective","getIdentifierForExplicitScopeObject","parentWithScope","bindings","scope","scopeName","Object","keys","key","id","uniqueIdentifier","generateUidIdentifier","push","kind","init","objectExpression","rewriteReadGlobal","prependGetGlobal","insertBefore","callExpression","wrapSetGlobal","valueToReturn","left","replaceWith","sequenceExpression","maybeWrapInStatement","wrapInReturnStatement","isStatement","isExpression","expressionNode","returnStatement","loc","console","error","wrapPropertyOfPath","oldBody","oldBodyNode","isBlockStatement","Array","newBodyNode","blockStatement","isArrowFunctionExpression","BlockParent","isProgram","isSwitchStatement","body","warn","IfStatement","SwitchCase","UnaryExpression","operator","argument","isMemberExpression","object","array","isArrayExpression","length","expr","arrowFunctionExpression","UpdateExpression","prefix","isIdentifier","assignment","assignmentExpression","numericLiteral","reverseOperator","binaryExpression","Identifier","logIdentifier","msg","log","start","line","isCallExpression","parent","hasBinding","fileName","filename","startsWith","split","sourceLocation","buildSourceLocation","wrapper","directives","end","type","sourceType","arguments","source","transformFromAst","code","END_COLUMN","column","END_LINE","START_COLUMN","START_LINE","SOURCE","expression","location","some","any","isSpreadElement","isObjectExpression","pushContainer","objectProperty","a","LOCATION","EXPR","isExportSpecifier","isMetaProperty","isAssignmentPattern","isUpdateExpression","isFunctionExpression","isImportDefaultSpecifier","isCatchClause","isContinueStatement","isObjectProperty","isClassDeclaration","isClassExpression","isClassMethod","isImportSpecifier","isObjectMethod","isRestElement","par","hasOwnBinding","hasGlobal","isReferencedIdentifier","AssignmentExpression","right","valueForAExpr","conditionalExpression","booleanLiteral","unaryExpression","MemberExpression","isBindExpression","isSuper","CallExpression","callee","isDuplicatableMemberExpression","memberPath","objectPath","isSimpleObject","isThisExpression","isComputedProperty","propertyPath","isSimpleProperty","isStringLiteral","getTraceIdentifierForSimpleObject","thisExpression","buildCodeFrameError","traceIdentifier","arrayExpression"],"mappings":"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","file":"index.js","sourcesContent":["import { isVariable } from './utils.js';\nimport Preferences from 'src/client/preferences.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(babel) {\n  let { types: t, template, traverse } = babel;\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    identifier[FLAG_SHOULD_NOT_REWRITE_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 isInDestructuringAssignment(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          function hasDirective(path, name) {\n            let foundDirective = false;\n            path.traverse({\n              Directive(path) {\n                if(path.get(\"value\").node.value === name) {\n                  foundDirective = true;\n                }\n              }\n            });\n            return foundDirective;\n          }\n\n          function shouldTransform() {\n            const proxyDirective = hasDirective(path, 'use proxies for aexprs');\n            const proxyPreference = Preferences.get('UseProxiesForAExprs');\n            const inWorkspace = state.opts.executedIn === 'workspace';\n            const inFile = state.opts.executedIn === 'file';\n\n            if (inWorkspace) {\n              return !proxyPreference;\n            } else if (inFile) {\n              return !proxyDirective;\n            }\n            return true;\n            throw new Error('This should not be possible');\n          }\n\n          if (!shouldTransform()) { return; }\n\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          if(state.opts.enableViaDirective && !hasDirective(path, \"enable aexpr\")) {\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          function rewriteReadGlobal(path) {\n            if (path.node.name !== 'eval') {\n              path.node[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n              prependGetGlobal(path);\n            }\n          }\n          function prependGetGlobal(path) {\n            path.insertBefore(\n              checkExpressionAnalysisMode(\n                t.callExpression(\n                  addCustomTemplate(state.file, GET_GLOBAL), [t.stringLiteral(path.node.name)]\n                )\n              )\n            );\n          }\n          function wrapSetGlobal(path) {\n            const 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          // ------------- 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(isInDestructuringAssignment(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(isInDestructuringAssignment(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            /*MD # Identifier MD*/\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                let fileName = state && state.file && state.file.log && state.file.log.filename || 'no_file_given';\n                if(fileName.startsWith('workspace:') && fileName.includes('unnamed_module_')) {\n                  fileName = 'workspace:'+fileName.split('unnamed_module_')[1];\n                }\n                const sourceLocation = template(`({\n                  file: '${fileName}',\n                  end: {\n                    column: END_COLUMN,\n                    line: END_LINE\n                  },\n                  start: {\n                    column: START_COLUMN,\n                    line: START_LINE\n                  },\n                  source: SOURCE\n                })`);\n                function buildSourceLocation(path) {\n                  let node = path.node;\n                  let wrapper = {\n                    directives: [],\n                    start: 0,\n                    end: 0,\n                    type: 'Program',\n                    sourceType: 'module',\n                    body: [path.parent.arguments[0]]\n                  };\n                  let source = babel.transformFromAst(wrapper, {sourceType: 'module'}).code;\n                  return sourceLocation({\n                    END_COLUMN: t.numericLiteral(node.loc.end.column),\n                    END_LINE: t.numericLiteral(node.loc.end.line),\n                    START_COLUMN: t.numericLiteral(node.loc.start.column),\n                    START_LINE: t.numericLiteral(node.loc.start.line),\n                    SOURCE: t.stringLiteral(source)\n                  }).expression;\n                }\n                let location = buildSourceLocation(path);\n                //logIdentifier(\"call to aexpr\", path);\n                path.replaceWith(\n                  addCustomTemplate(state.file, AEXPR_IDENTIFIER_NAME)\n                );\n                if(path.parentPath.get('arguments').some(any => any.isSpreadElement())){return}\n                if(path.parentPath.get('arguments').length > 1) {\n                  let argument = path.parentPath.get('arguments')[1];\n                  if(argument.isObjectExpression()){\n                    argument.pushContainer('properties', t.objectProperty(t.identifier('location'), location));\n                  } else {\n                    let assignment = template(`Object.assign({location : LOCATION}, EXPR || {})`);\n                    let a = assignment({LOCATION : location, EXPR : argument}).expression;\n                    argument.replaceWith(a);\n                  }\n                  // path.parentPath.pushContainer('arguments', t.objectExpression([\n                  //   t.objectProperty(t.identifier('location'), location)\n                  // ]));\n                } else {\n                  path.parentPath.pushContainer('arguments', t.objectExpression([\n                    t.objectProperty(t.identifier('location'), location)\n                  ]));\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(isInDestructuringAssignment(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                  } else if (path.scope.hasGlobal(path.node.name)) {\n                    // #TODO: remove this code duplication\n                    rewriteReadGlobal(path);\n                  } else {\n                    // #TODO: can this be the case? Neither locally scoped nor global.\n                  }\n                } else {\n                  //logIdentifier('get global var', path);\n                  rewriteReadGlobal(path);\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            /*MD # AssigmentExpression MD*/\n            AssignmentExpression(path) {\n              if(isInForLoopIterator(path)) { return; }\n              if(isInDestructuringAssignment(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                  } else if (path.get('left').scope.hasGlobal(path.node.left.name)) {\n                    path.node[FLAG_SHOULD_NOT_REWRITE_ASSIGNMENT_EXPRESSION] = true;\n                    wrapSetGlobal(path);\n                  } else {\n                    // #TODO: can this be the case? Neither locally scoped nor global.\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                  wrapSetGlobal(path);\n                }\n              }\n\n            },\n\n            /*MD # MemberExpression MD*/\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(isInDestructuringAssignment(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            /*MD # CallExpression MD*/\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(isInDestructuringAssignment(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"]}