fine_granular ast copying

SQUASHED: AUTO-COMMIT-demos-tom-copyAST.js,AUTO-COMMIT-demos-tom-copy.js,AUTO-COMMIT-demos-tom-Events.js,AUTO-COMMIT-demos-tom-playground.js,AUTO-COMMIT-demos-tom-trace.js,AUTO-COMMIT-demos-tom-wrapAST.js,AUTO-COMMIT-src-components-tools-trace-visualization.js,

Author: BraunTom

demos/tom/Events.js

@@ -51,8 +51,6 @@ export class ASTChangeEvent {
     }
 
     getNode(id, astNode) {
-
-
         if (astNode.type) {
             const isSearchedNode = value => value && value.traceID !== undefined && value.traceID.nodeID === id.nodeID;
 
@@ -90,24 +88,49 @@ export class ASTChangeEvent {
                         if (isSearchedNode(node)) {
                             return node;
                         }
-                        // fallthrough as we want to know if a node is replaced
+                        break;
                     default:
                         // ignore value
                 }
             }
         }
     }
+    
+    resolve(copy, ast) {
+        
+        // Todo: optimize by caching: traceID -> ASTNode
+        if(copy.isTraceID) {
+            return this.getNode(copy, ast);
+        } else if(Array.isArray(copy)) {
+            const result = [];
+            for(const entry of copy) {
+                result.push(this.resolve(entry, ast));
+            }
+            return result;
+        } else if(copy.traceID) { // is astNode
+            const result = {};
+            
+            for(const key in copy) {
+                // do not expand the reference of the object itself
+                if(key === 'traceID') {
+                    result[key] = copy[key];
+                    continue;
+                }
+                result[key] = this.resolve(copy[key], ast);
+            }
+            
+            return result;
+        } else {
+            return copy;
+        }
+    }
 
     apply(ast) {
         let astNode = this.getNode(this.objectID, ast);
         if (this.arrayProperty) {
             astNode = astNode[this.arrayProperty];
         }
-        astNode[this.propertyName] = this.newValue;
-    }
-
-    revert(ast) {
-
+        astNode[this.propertyName] = this.resolve(this.newValue, ast);
     }
 
     visit(object) {

demos/tom/copyAST.js

@@ -0,0 +1,57 @@
+function copyArrayOfRound(arr, roundNumber) {
+    const copy = [];
+    
+    for(const entry of arr) {
+        copy.push(copyASTPartsOfRound(entry, roundNumber));
+    }
+    
+    return copy;
+}
+
+export default function copyASTPartsOfRound(object, roundNumber) {
+    // simply check if the object is an astNode
+    if (object && object.type) {
+        // if already in AST return only a reference
+        if (object.traceID && object.traceID.pluginRoundID !== roundNumber) {
+            return object.traceID;
+        }
+        
+        const objectCopy = {};
+        const keys = Object.keys(object).filter(key => key[0] !== '_');
+        for (const key of keys) {
+            const value = object[key];
+
+            if (Array.isArray(value)) {
+                objectCopy[key] = copyArrayOfRound(value, roundNumber);
+
+                continue;
+            }
+
+            if (value === null) {
+                objectCopy[key] = value;
+                continue;
+            }
+
+            switch (typeof value) {
+                case 'function':
+                    // ignore functions
+                    break;
+                case 'object':
+                    // assume it is an astNode
+                    objectCopy[key] = copyASTPartsOfRound(value, roundNumber);
+                    break;
+                default:
+                    objectCopy[key] = value;
+            }
+        }
+        
+        return objectCopy;
+    } else {
+        if(Array.isArray(object)) {
+            return copyArrayOfRound(object, roundNumber);
+        } else {
+            // do a simple copy
+            return JSON.parse(JSON.stringify(object));
+        }
+    }
+}

demos/tom/playground.js

@@ -2,7 +2,7 @@ export default function({types: t}) {
     return {
         name: 'test',
         visitor: {
-            Function(path) {
+            FunctionDeclaration(path) {
                 if(path.node.alreadyVisited) {
                     return;
                 }

demos/tom/trace.js

@@ -14,7 +14,9 @@ function clone(object) {
 export default class Trace {
     constructor() {
         this._log = [];
+        
         this.counter = 0;
+        this.pluginRound = 0;
 
         this.locations = [];
         this.filenames = [];
@@ -32,7 +34,7 @@ export default class Trace {
 
     createTraceID() {
         return {
-            sectionID: 0,
+            pluginRoundID: this.pluginRound,
             nodeID: this.counter++,
             isTraceID: true
         }
@@ -132,7 +134,7 @@ export default class Trace {
     /* AST changes */
 
     notify(objectID, key, oldValue, newValue, arrayProperty) {
-        const event = new ASTChangeEvent(objectID, key, clone(oldValue), clone(newValue));
+        const event = new ASTChangeEvent(objectID, key, oldValue, newValue);
         this.log(event);
         event.arrayProperty = arrayProperty;
     }
@@ -141,6 +143,7 @@ export default class Trace {
 
     enterPlugin(name) {
         this.log(new Event('enterPlugin', name));
+        this.pluginRound++;
     }
 
     leavePlugin(name) {

demos/tom/wrapAST.js

@@ -1,19 +1,20 @@
 import Trace from 'demos/tom/trace.js';
+import copyAST from 'demos/tom/copyAST.js';
 
-const excludedProperties = ['end', 'loc', 'start', 'traceID', 'type'];
-
-function copy(value) {
-    return value; // JSON.parse(JSON.stringify(value));
-}
+export const excludedProperties = ['end', 'loc', 'start', 'traceID', 'type'];
 
 function createObservingAccessorsOn(object, propertyName, observer) {
     const newPropertyName = '_' + propertyName;
     object[newPropertyName] = object[propertyName];
     Object.defineProperty(object, propertyName, {
         get() { return object[newPropertyName]; },
         set(value) {
-            observer.notify(object.traceID, propertyName, object[newPropertyName], value);
+            const pluginRound = window[Trace.traceIdentifierName].pluginRound;
             wrapAST(value, observer, true);
+            observer.notify(object.traceID, 
+                            propertyName, 
+                            copyAST(object[newPropertyName], pluginRound), 
+                            copyAST(value, pluginRound));
             object[newPropertyName] = value;
         }
     })
@@ -24,8 +25,10 @@ const handler = (observer, key) => {
         set: function(obj, prop, value) {
             // Todo: Reflect.set()
             if (Number.isInteger(Number.parseInt(prop))) {
-                observer.notify(prop, copy(obj[prop]), copy(value), key);
+                const pluginRound = window[Trace.traceIdentifierName].pluginRound;
+                debugger
                 wrapAST(value, observer, true);
+                observer.notify(prop, copyAST(obj[prop], pluginRound), copyAST(value, pluginRound), key);
             }
             obj[prop] = value;
             return true;
@@ -37,56 +40,6 @@ function wrappedArray(array, observer, key) {
     return new Proxy(array, handler(observer, key));
 }
 
-function copyUnknownASTParts(astNode) {
-    // simply check if the object is an astNode
-    if (astNode && astNode.type) {
-        // if already in AST return only a reference
-        if (astNode.traceID) {
-            return astNode.traceID;
-        }
-        
-        const objectCopy = {};
-
-        const keys = Object.keys(astNode).filter(key => !excludedProperties.includes(key));
-        for (const key of keys) {
-            const value = astNode[key];
-
-            if (Array.isArray(value)) {
-                const copiedArray = [];
-                objectCopy[key] = copiedArray;
-                
-                for(const entry of value) {
-                    copiedArray.push(copyUnknownASTParts(entry));
-                }
-
-                continue;
-            }
-
-            if (value === null) {
-                objectCopy[key] = value;
-                continue;
-            }
-
-            switch (typeof value) {
-                case 'function':
-                    // ignore functions
-                    break;
-                case 'object':
-                    // assume it is an astNode
-                    objectCopy[key] = copyUnknownASTParts(value);
-                    break;
-                default:
-                    objectCopy[key] = value;
-            }
-        }
-        
-        return objectCopy;
-    } else {
-        // probably not an AST node => do a generic copy
-        return JSON.parse(JSON.stringify(astNode));
-    }
-}
-
 export default function wrapAST(astNode, observer, onlyUnknownNodes) {
     // simply check if the object is an astNode
     if (astNode && astNode.type) {

src/components/tools/trace-visualization.js

@@ -197,6 +197,8 @@ export default class TraceVisualization extends Morph {
     updateAST(path, entry) {
         this.curAST = JSON.parse(JSON.stringify(this.trace.oldAST));
         this.nextAST;
+                                          
+                                          debugger
 
         let entries = this.trace.sections;