{"version":3,"sources":["https://lively-kernel.org/lively4/swt21-debugging/src/client/reactive/babel-plugin-active-expression-rewriting/index.js"],"names":["isVariable","Preferences","getSourceLocation","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","node","state","template","t","fileName","file","log","filename","startsWith","includes","split","loc","console","error","left","name","right","identifier","sourceLocation","END_COLUMN","numericLiteral","end","column","END_LINE","line","START_COLUMN","start","START_LINE","expression","babel","types","traverse","getPropertyFromMemberExpression","computed","property","stringLiteral","GENERATED_FUNCTION","isGenerated","findParent","p","isFunctionDeclaration","tNonRewritable","Proxy","get","target","prop","receiver","args","nonRewritableIdentifier","GENERATED_IMPORT_IDENTIFIER","addCustomTemplate","declar","declarations","addImport","checkExpressionAnalysisMode","ifStatement","memberExpression","expressionStatement","isInForLoopIterator","isInForLoop","find","parentPath","isForStatement","parentKey","isForInStatement","isForOfStatement","isInDestructuringAssignment","patternParent","isPattern","inVarDefinition","isVariableDeclarator","inAssignment","isAssignmentExpression","inParams","isFunction","pre","visitor","Program","enter","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","objectProperty","booleanLiteral","rewriteReadGlobal","prependGetGlobal","insertBefore","callExpression","wrapSetGlobal","valueToReturn","parameters","replaceWith","sequenceExpression","setClassFilePathStatement","assignmentExpression","thisExpression","isClassFilePathStatement","statement","isExpressionStatement","isMemberExpression","isIdentifier","isCallExpression","arguments","length","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","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","isClassProperty","par","hasOwnBinding","trackingCode","isConstant","getBinding","constantViolations","scopeHasEval","CallExpression","callee","objectIdentifier","hasGlobal","isReferencedIdentifier","AssignmentExpression","valueForAExpr","conditionalExpression","unaryExpression","MemberExpression","isBindExpression","isSuper","methodName","databindingFlag","isBooleanLiteral","lively","notify","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.\nexport const FLAG_GENERATED_SCOPE_OBJECT = Symbol('FLAG: generated scope object');\nexport const FLAG_SHOULD_NOT_REWRITE_IDENTIFIER = Symbol('FLAG: should not rewrite identifier');\nexport const FLAG_SHOULD_NOT_REWRITE_MEMBER_EXPRESSION = Symbol('FLAG: should not rewrite member expression');\nexport const FLAG_SHOULD_NOT_REWRITE_CALL_EXPRESSION = Symbol('FLAG: should not rewrite call expression');\nexport const 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 function getSourceLocation(node, state, template, t) {\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  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\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([t.objectProperty(t.identifier(\"isScope\"), t.booleanLiteral(true))])\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            \n            const parameters = [t.stringLiteral(path.node.left.name)];\n            if(Preferences.get(\"EnableAEDebugging\")) {\n              parameters.push(getSourceLocation(path.node, state, template, t));\n            }\n            \n            path.replaceWith(t.sequenceExpression([path.node, t.callExpression(addCustomTemplate(state.file, SET_GLOBAL), parameters), 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          // ------------- 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                if(!Preferences.get(\"EnableAEDebugging\")) {\n                  return;\n                }\n                const location = getSourceLocation(path.node, state, template, t);\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')) && (!t.isClassProperty(path.parent) || !(path.parentKey === 'key'))) {\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                let parameters = [path.node.left.object, getPropertyFromMemberExpression(path.node.left), path.node.right];\n                if(Preferences.get(\"EnableAEDebugging\")) {\n                  parameters.push(getSourceLocation(path.node, state, template, t));\n                }\n                \n                //state.file.addImport\n                path.replaceWith(t.callExpression(addCustomTemplate(state.file, SET_MEMBER_BY_OPERATORS[path.node.operator]), parameters));\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                    const parameters = [getIdentifierForExplicitScopeObject(parentWithScope), t.stringLiteral(path.node.left.name), valueForAExpr];\n                    if(Preferences.get(\"EnableAEDebugging\")) {\n                      parameters.push(getSourceLocation(path.node, state, template, t));\n                    }\n                    path.replaceWith(t.sequenceExpression([path.node, t.conditionalExpression(t.booleanLiteral(true), t.callExpression(addCustomTemplate(state.file, SET_LOCAL), parameters), 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                    if(args.length > 1) {\n                      const databindingFlag = args[1];\n                      if(t.isBooleanLiteral(databindingFlag.node, {value: true})) {\n                        lively.notify(\"Databinding detected\");\n                        debugger;                        \n                      }\n                    }\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}"]}