{"version":3,"sources":["https://lively-kernel.org/lively4/swt1-debugging/src/client/reactive/babel-plugin-active-expression-rewriting/index.js"],"names":["isVariable","Preferences","markMemberToNotBeRewritten","AEXPR_IDENTIFIER_NAME","AEXPR_SHORTHAND_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","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","getSourceLocation","setClassFilePathStatement","fileName","log","filename","startsWith","split","assignmentExpression","thisExpression","loc","isClassFilePathStatement","statement","isExpressionStatement","expression","isMemberExpression","isIdentifier","isCallExpression","arguments","length","console","error","right","sourceLocation","END_COLUMN","numericLiteral","end","column","END_LINE","line","START_COLUMN","start","START_LINE","maybeWrapInStatement","wrapInReturnStatement","isStatement","isExpression","expressionNode","returnStatement","wrapPropertyOfPath","oldBody","oldBodyNode","isBlockStatement","Array","newBodyNode","blockStatement","isArrowFunctionExpression","hasInitialize","BlockParent","isProgram","isSwitchStatement","body","warn","IfStatement","SwitchCase","ClassMethod","UnaryExpression","operator","argument","object","UpdateExpression","prefix","assignment","reverseOperator","binaryExpression","bodyStatements","lastStatement","pushContainer","ClassDeclaration","classBody","some","classElement","isClassMethod","constructorContent","superClass","super","spreadElement","unshiftContainer","classMethod","restElement","Identifier","logIdentifier","msg","addAsObjectPropertyAsSecondParameter","functionCallPath","propertyName","any","isSpreadElement","objectProperty","isObjectExpression","assign","assigned","PROPERTY","EXPR","formatCode","source","addOriginalSourceCode","aexprIdentifierPath","expressionPath","sourceCode","getSource","formattedCode","addSourceMetaData","location","isCallee","parent","hasUnboundName","hasBinding","arrowFunctionExpression","isExportSpecifier","isMetaProperty","isAssignmentPattern","isUpdateExpression","isFunctionExpression","isImportDefaultSpecifier","isCatchClause","isContinueStatement","isObjectProperty","isClassDeclaration","isClassExpression","isImportSpecifier","isObjectMethod","isRestElement","par","hasOwnBinding","trackingCode","isConstant","getBinding","constantViolations","scopeHasEval","CallExpression","callee","objectIdentifier","hasGlobal","isReferencedIdentifier","AssignmentExpression","valueForAExpr","conditionalExpression","booleanLiteral","unaryExpression","MemberExpression","isBindExpression","isSuper","methodName","isDuplicatableMemberExpression","memberPath","objectPath","isSimpleObject","isThisExpression","isComputedProperty","propertyPath","isSimpleProperty","isStringLiteral","getTraceIdentifierForSimpleObject","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\n//import 'src/client/js-beautify/beautify.js'\n\nconst AEXPR_IDENTIFIER_NAME = 'aexpr';\nconst AEXPR_SHORTHAND_NAME = 'ae';\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    const declar = file.declarations[name];\n    if (declar) {\n      return declar;\n    }\n\n    const 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(markMemberToNotBeRewritten(t.memberExpression(nonRewritableIdentifier('self'), nonRewritableIdentifier('__expressionAnalysisMode__'))), 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()) {\n        return false;\n      }\n      if (!p.parentPath) {\n        return false;\n      }\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    name: 'active-expression-rewriting',\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()) {\n            return;\n          }\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 && bindings[key].path.node && bindings[key].path.node.id && 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(checkExpressionAnalysisMode(t.callExpression(addCustomTemplate(state.file, GET_GLOBAL), [t.stringLiteral(path.node.name)])));\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(t.sequenceExpression([path.node, t.callExpression(addCustomTemplate(state.file, SET_GLOBAL), [t.stringLiteral(path.node.left.name), getSourceLocation(path)]), valueToReturn]));\n          }\n          function setClassFilePathStatement() {\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 assignmentExpression = t.assignmentExpression(\"=\", t.memberExpression(t.thisExpression(), t.identifier(\"__classFilePath__\")), t.stringLiteral(fileName));\n            assignmentExpression.loc = \"sourceless\";\n\n            return t.expressionStatement(assignmentExpression);\n          }\n\n          function isClassFilePathStatement(statement) {\n            if (!t.isExpressionStatement(statement)) return false;\n            if (t.isAssignmentExpression(statement.expression)) {\n              return t.isMemberExpression(statement.expression.left) && t.isIdentifier(statement.expression.left.property) && statement.expression.left.property.name === \"__classFilePath__\";\n            } else if (t.isCallExpression(statement.expression)) {\n              return statement.expression.arguments.length >= 2 && statement.expression.arguments[1].value === \"__classFilePath__\";\n            }\n            return false;\n          }\n\n          function getSourceLocation(path) {\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 node = path.node;\n            if (!node.loc) {\n\n              console.error(\"Make sure to add loc information manually when inserting an AE or assignment while transforming\" + node.left.name + \" = \" + node.right.name);\n              return t.identifier(\"undefined\");\n            }\n            if (node.loc === \"sourceless\") {\n              return t.identifier(\"undefined\");\n            }\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: ''\n            })`);\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: source\n              ) }).expression;\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          let hasInitialize = false;\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            ClassMethod(path) {\n              if (path.node.key.name === \"initialize\") {\n                hasInitialize = true;\n              }\n            }\n          });\n\n          path.traverse({\n\n            UnaryExpression(path) {\n              if (isInForLoopIterator(path)) {\n                return;\n              }\n              if (isInDestructuringAssignment(path)) {\n                return;\n              }\n\n              // handle delete operator\n              if (path.node.operator === 'delete') {\n                const argument = path.get('argument');\n                if (argument.isMemberExpression()) {\n                  path.replaceWith(t.callExpression(addCustomTemplate(state.file, DELETE_MEMBER), [argument.node.object, getPropertyFromMemberExpression(argument.node)]));\n                }\n                return;\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)) {\n                return;\n              }\n              if (isInDestructuringAssignment(path)) {\n                return;\n              }\n\n              if (argument.isMemberExpression() || argument.isIdentifier()) {\n\n                // ++v -> v += 1\n                let assignment = t.assignmentExpression(operator[0] + '=', argument.node, t.numericLiteral(1));\n                assignment.loc = path.node.loc;\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(reverseOperator, assignment, t.numericLiteral(1));\n                  assignment.loc = path.node.loc;\n                }\n                path.replaceWith(assignment);\n              }\n            },\n\n            ClassMethod(path) {\n              if (hasInitialize ? path.node.key.name !== \"initialize\" : path.node.kind !== \"constructor\") return;\n              const bodyStatements = path.node.body.body;\n              const lastStatement = bodyStatements[bodyStatements.length - 1];\n              if (bodyStatements.length === 0 || !isClassFilePathStatement(lastStatement)) {\n                path.get('body').pushContainer('body', setClassFilePathStatement());\n              }\n            },\n\n            ClassDeclaration(path) {\n              if (hasInitialize) return;\n              const classBody = path.node.body;\n              if (!classBody.body.some(classElement => t.isClassMethod(classElement) && classElement.kind === \"constructor\")) {\n                // No constructor exists -> Override default constructor\n                const constructorContent = [];\n                if (path.node.superClass) {\n                  constructorContent.push(t.expressionStatement(t.callExpression(t.super(), [t.spreadElement(t.identifier(\"args\"))])));\n                }\n                constructorContent.push(setClassFilePathStatement());\n                path.get(\"body\").unshiftContainer(\"body\", t.classMethod(\"constructor\", t.identifier(\"constructor\"), [t.restElement(t.identifier(\"args\"))], t.blockStatement(constructorContent)));\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              function addAsObjectPropertyAsSecondParameter(functionCallPath, propertyName, node) {\n                const args = functionCallPath.get('arguments');\n\n                /* #TODO: Support the following cases:\n                 * ae(expr)\n                 * ae(expr, { })\n                 * ae(expr, obj)\n                 * ae(expr, ...arr)\n                 * ae(...arr)\n                 */\n                if (args.some(any => any.isSpreadElement())) {\n                  return;\n                }\n\n                if (args.length === 0) {\n                  return;\n                }\n\n                if (args.length === 1) {\n                  functionCallPath.pushContainer('arguments', t.objectExpression([t.objectProperty(t.identifier(propertyName), node)]));\n                  return;\n                }\n\n                const argument = args[1];\n                if (argument.isObjectExpression()) {\n                  argument.pushContainer('properties', t.objectProperty(t.identifier(propertyName), node));\n                } else {\n                  const assign = template(`Object.assign({${propertyName} : PROPERTY}, EXPR || {})`);\n                  const assigned = assign({ PROPERTY: node, EXPR: argument }).expression;\n                  argument.replaceWith(assigned);\n                }\n              }\n              \n              function formatCode(source) {\n                //Seems like this is too big to import properly\n                //System.import(\"src/client/js-beautify/beautify.js\")\n                //debugger;\n                //return global.js_beautify(source);\n                return source;\n              }\n\n              function addOriginalSourceCode(aexprIdentifierPath) {\n                const args = aexprIdentifierPath.parentPath.get('arguments');\n                if (args.length === 0) {\n                  return;\n                }\n                const expressionPath = args[0];\n                const sourceCode = expressionPath.getSource();\n                \n                const formattedCode = formatCode(sourceCode);\n                \n                if (sourceCode) {\n                  addAsObjectPropertyAsSecondParameter(aexprIdentifierPath.parentPath, 'sourceCode', t.stringLiteral(formattedCode));\n                }\n              }\n\n              function addSourceMetaData(path) {\n                const location = getSourceLocation(path);\n                addAsObjectPropertyAsSecondParameter(path.parentPath, 'location', location);\n                addOriginalSourceCode(path);\n              }\n\n              const isCallee = t.isCallExpression(path.parent) && path.parentKey === 'callee';\n              function hasUnboundName(name) {\n                // #TODO: in workspaces, this might lead to an issue, as we may override\n                // a module-global variable that was declared in an earlier execution\n                return path.node.name === name && !path.scope.hasBinding(name);\n              }\n\n              // Check for a call to undeclared `aexpr`:\n              if (isCallee && hasUnboundName(AEXPR_IDENTIFIER_NAME)) {\n                addSourceMetaData(path);\n\n                path.replaceWith(addCustomTemplate(state.file, AEXPR_IDENTIFIER_NAME));\n                return;\n              }\n\n              // Check for a call to undeclared `ae`:\n              if (isCallee && hasUnboundName(AEXPR_SHORTHAND_NAME)) {\n                addSourceMetaData(path);\n\n                const expressionPath = path.parentPath.get('arguments')[0];\n                if (expressionPath) {\n                  expressionPath.replaceWith(t.arrowFunctionExpression([], expressionPath.node));\n                }\n\n                path.replaceWith(addCustomTemplate(state.file, AEXPR_IDENTIFIER_NAME));\n                return;\n              }\n\n              // property local of ExportStatement\n              if (t.isExportSpecifier(path.parent) && path.parentKey === 'local') {\n                return;\n              }\n\n              if (\n              // TODO: is there a general way to exclude non-variables?\n              isVariable(path) && !t.isMetaProperty(path.parent) && !(t.isForInStatement(path.parent) && path.parentKey === 'left') && !(t.isAssignmentPattern(path.parent) && path.parentKey === 'left') && !t.isUpdateExpression(path.parent) && !(t.isFunctionExpression(path.parent) && path.parentKey === 'id') && !(t.isImportDefaultSpecifier(path.parent) && path.parentKey === 'local') && !(t.isCatchClause(path.parent) && path.parentKey === 'param') && !(t.isContinueStatement(path.parent) && path.parentKey === 'label') && !t.isObjectProperty(path.parent) && !t.isClassDeclaration(path.parent) && !t.isClassExpression(path.parent) && !t.isClassMethod(path.parent) && !t.isImportSpecifier(path.parent) && !t.isObjectMethod(path.parent) && !(t.isVariableDeclarator(path.parent) && path.parentKey === 'id') && !t.isFunctionDeclaration(path.parent) && !(t.isArrowFunctionExpression(path.parent) && path.parentKey === 'params') && !(t.isExportSpecifier(path.parent) && path.parentKey === 'exported') && !(t.isFunctionExpression(path.parent) && path.parentKey === 'params') && !t.isRestElement(path.parent) && (!t.isAssignmentExpression(path.parent) || !(path.parentKey === 'left'))) {\n                if (isInForLoopIterator(path)) {\n                  return;\n                }\n                if (isInDestructuringAssignment(path)) {\n                  return;\n                }\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 => par.scope.hasOwnBinding(path.node.name));\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                    // #TODO: we cannot ignore non-changing values, as the ae might be configured to e.g. match:shallow\n                    // then, a local might still be considered to have changed w/o \n                    // const varBinding = path.scope.getBinding(path.node.name);\n                    // const isConst = varBinding.kind === \"const\";\n                    // const isNotChanging = varBinding.constantViolations.length === 0;\n                    // if (!isConst && !isNotChanging) {\n                    \n                    \n                    let trackingCode = checkExpressionAnalysisMode(t.callExpression(addCustomTemplate(state.file, GET_LOCAL), [getIdentifierForExplicitScopeObject(parentWithScope), t.stringLiteral(path.node.name), nonRewritableIdentifier(path.node.name)]));\n                    const isConstant = path.scope.getBinding(path.node.name).constantViolations.length === 0;\n                    if(isConstant) {\n                      \n                      let scopeHasEval = false;\n                      path.scope.getBinding(path.node.name).scope.path.traverse({\n                        CallExpression(path) {\n                          if (t.isIdentifier(path.node.callee) && path.node.callee.name === \"eval\") {\n                            scopeHasEval = true;\n                          }\n                        }\n                      });\n                      if(!scopeHasEval) {\n                        //If a variable is constant and primitive, we never have to track it, since changing it cannot influence any AEs. So this adds the primitive check at runtime.\n                        const objectIdentifier = t.identifier(\"Object\");\n                        objectIdentifier[FLAG_SHOULD_NOT_REWRITE_IDENTIFIER] = true;\n                        trackingCode = t.ifStatement(t.binaryExpression(\"===\", path.node, t.callExpression(objectIdentifier, [path.node])), trackingCode, t.expressionStatement(path.node));          \n                      }\n                    }\n                    path.insertBefore(trackingCode);\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)) {\n                return;\n              }\n              if (isInDestructuringAssignment(path)) {\n                return;\n              }\n              // check, whether we assign to a member (no support for pattern right now)\n              if (t.isMemberExpression(path.node.left) && !isGenerated(path) && SET_MEMBER_BY_OPERATORS[path.node.operator]) {\n\n                //state.file.addImport\n                path.replaceWith(t.callExpression(addCustomTemplate(state.file, SET_MEMBER_BY_OPERATORS[path.node.operator]), [path.node.left.object, getPropertyFromMemberExpression(path.node.left),\n                //t.stringLiteral(path.node.operator),\n                path.node.right, getSourceLocation(path)]));\n              }\n\n              if (t.isIdentifier(path.node.left) && !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 => par.scope.hasOwnBinding(path.node.left.name));\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(t.sequenceExpression([path.node, t.conditionalExpression(t.booleanLiteral(true), t.callExpression(addCustomTemplate(state.file, SET_LOCAL), [getIdentifierForExplicitScopeObject(parentWithScope), t.stringLiteral(path.node.left.name), valueForAExpr, getSourceLocation(path)]), t.unaryExpression('void', t.numericLiteral(0))), valueToReturn]));\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            /*MD # MemberExpression MD*/\n            MemberExpression(path) {\n              // lval (left values) are ignored for now\n              if (path.parentPath.isCallExpression() && path.parentKey === \"callee\") {\n                return;\n              }\n              // #TODO: BindExpressions are ignored for now; they are static anyway ;)\n              if (path.parentPath.isBindExpression() && path.parentKey === \"callee\") {\n                return;\n              }\n              if (t.isAssignmentExpression(path.parent) && path.key === 'left') {\n                return;\n              }\n              if (t.isUpdateExpression(path.parent) && path.key === 'argument') {\n                return;\n              }\n              if (t.isSuper(path.node.object)) {\n                return;\n              }\n              if (isGenerated(path)) {\n                return;\n              }\n              if (isInForLoopIterator(path)) {\n                return;\n              }\n              if (isInDestructuringAssignment(path)) {\n                return;\n              }\n              if (path.node[FLAG_SHOULD_NOT_REWRITE_MEMBER_EXPRESSION]) {\n                return;\n              }\n\n              path.replaceWith(t.callExpression(addCustomTemplate(state.file, GET_MEMBER), [path.node.object, getPropertyFromMemberExpression(path.node)]));\n            },\n\n            /*MD # CallExpression MD*/\n            CallExpression(path) {\n              if (isGenerated(path)) {\n                return;\n              }\n              if (path.node.callee && t.isSuper(path.node.callee.object)) {\n                return;\n              }\n              if (path.node[FLAG_SHOULD_NOT_REWRITE_CALL_EXPRESSION]) {\n                return;\n              }\n              if (isInForLoopIterator(path)) {\n                return;\n              }\n              if (isInDestructuringAssignment(path)) {\n                return;\n              }\n\n              if (t.isMemberExpression(path.node.callee)) {\n                const methodName = path.node.callee.property.name;\n                if (methodName === \"dataflow\" || methodName === \"onChange\" || methodName === \"offChange\") {\n                  const args = path.get('arguments');\n                  if (args.length > 0) {\n                    const expressionPath = args[0];\n                    const sourceCode = expressionPath.getSource();\n                    path.pushContainer('arguments', t.objectExpression([t.objectProperty(t.identifier(\"sourceCode\"), t.stringLiteral(sourceCode))]));\n                  }\n                  //addOriginalSourceCode(path);\n                  return;\n                }\n              }\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() || 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(checkExpressionAnalysisMode(t.callExpression(addCustomTemplate(state.file, TRACE_MEMBER), [traceIdentifier, getPropertyFromMemberExpression(path.node.callee)])));\n                } else {\n                  path.replaceWith(t.callExpression(addCustomTemplate(state.file, GET_AND_CALL_MEMBER), [path.node.callee.object, getPropertyFromMemberExpression(path.node.callee), t.arrayExpression(path.node.arguments)]));\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}"]}