bumping js-slang (#2885)

* Frontend changes for js-slang PR #1600

* bumping js-slang

* Update tests, workaround `stream_tail` problems

* Formatting

* Update comment

---------

Co-authored-by: CZX <CZX123@users.noreply.github.com>

Author: martin-henz

package.json

@@ -50,7 +50,7 @@
     "flexboxgrid": "^6.3.1",
     "flexboxgrid-helpers": "^1.1.3",
     "hastscript": "^9.0.0",
-    "js-slang": "^1.0.52",
+    "js-slang": "^1.0.55",
     "js-yaml": "^4.1.0",
     "konva": "^9.2.0",
     "lodash": "^4.17.21",

src/commons/mocks/ContextMocks.ts

@@ -36,6 +36,7 @@ export function mockRuntimeContext(): Context {
     ],
     control: null,
     stash: null,
+    objectCount: 0,
     envStepsTotal: 0,
     breakpointSteps: [],
     changepointSteps: []

src/features/cseMachine/CseMachineLayout.tsx

@@ -1,10 +1,11 @@
+import Heap from 'js-slang/dist/cse-machine/heap';
 import { Control, Stash } from 'js-slang/dist/cse-machine/interpreter';
-import { Frame } from 'js-slang/dist/types';
 import { KonvaEventObject } from 'konva/lib/Node';
 import React, { RefObject } from 'react';
 import { Layer, Rect, Stage } from 'react-konva';
 import classes from 'src/styles/Draggable.module.scss';
 
+import { Binding } from './components/Binding';
 import { ControlStack } from './components/ControlStack';
 import { Level } from './components/Level';
 import { StashStack } from './components/StashStack';
@@ -17,17 +18,26 @@ import { Value } from './components/values/Value';
 import CseMachine from './CseMachine';
 import { CseAnimation } from './CseMachineAnimation';
 import { Config, ShapeDefaultProps } from './CseMachineConfig';
-import { Data, EnvTree, EnvTreeNode, ReferenceType } from './CseMachineTypes';
 import {
+  Closure,
+  Data,
+  DataArray,
+  EnvTree,
+  EnvTreeNode,
+  GlobalFn,
+  ReferenceType
+} from './CseMachineTypes';
+import {
+  convertClosureToGlobalFn,
   deepCopyTree,
   getNextChildren,
-  isArray,
-  isDummyKey,
-  isFn,
+  isClosure,
+  isDataArray,
   isFunction,
   isGlobalFn,
   isPrimitiveData,
-  isUnassigned
+  isUnassigned,
+  setDifference
 } from './CseMachineUtils';
 
 /** this class encapsulates the logic for calculating the layout */
@@ -135,8 +145,8 @@ export class Layout {
     Layout.control = control;
     Layout.stash = stash;
 
-    // remove program environment and merge bindings into global env
-    Layout.removeProgramEnv();
+    // remove prelude environment and merge bindings into global env
+    Layout.removePreludeEnv();
     // remove global functions that are not referenced in the program
     Layout.removeUnreferencedGlobalFns();
     // initialize levels and frames
@@ -182,76 +192,128 @@ export class Layout {
     this.stashComponent = new StashStack(this.stash);
   }
 
-  /** remove program environment containing predefined functions */
-  private static removeProgramEnv() {
+  /**
+   * remove prelude environment containing predefined functions, by merging the prelude
+   * objects into the global environment head and heap
+   */
+  private static removePreludeEnv() {
     if (!Layout.globalEnvNode.children) return;
 
-    const programEnvNode = Layout.globalEnvNode.children[0];
+    const preludeEnvNode = Layout.globalEnvNode.children[0];
+    const preludeEnv = preludeEnvNode.environment;
     const globalEnvNode = Layout.globalEnvNode;
+    const globalEnv = globalEnvNode.environment;
 
-    // merge programEnvNode bindings into globalEnvNode
-    globalEnvNode.environment.head = {
-      ...programEnvNode.environment.head,
-      ...globalEnvNode.environment.head
-    };
+    const preludeValueKeyMap = new Map(
+      Object.entries(preludeEnv.head).map(([key, value]) => [value, key])
+    );
 
-    // update globalEnvNode children
-    if (programEnvNode.children) {
-      globalEnvNode.resetChildren(programEnvNode.children);
+    // Change environments of each array and closure in the prelude to be the global environment
+    for (const value of preludeEnv.heap.getHeap()) {
+      Object.defineProperty(value, 'environment', { value: globalEnvNode.environment });
+      globalEnv.heap.add(value);
+      const key = preludeValueKeyMap.get(value);
+      if (key) {
+        globalEnv.head[key] = value;
+      }
     }
 
-    // go through new bindings and update functions to be global functions
-    // by removing extra props such as functionName
-    for (const value of Object.values(globalEnvNode.environment.head)) {
-      if (isFn(value)) {
-        delete (value as { functionName?: string }).functionName;
+    // update globalEnvNode children
+    globalEnvNode.resetChildren(preludeEnvNode.children);
+
+    // update the tail of each child's environment to point to the global environment
+    globalEnvNode.children.forEach(node => {
+      node.environment.tail = globalEnv;
+    });
+
+    // go through new bindings and update closures to be global functions
+    for (const value of Object.values(globalEnv.head)) {
+      if (isClosure(value)) {
+        convertClosureToGlobalFn(value);
       }
     }
   }
 
   /** remove any global functions not referenced elsewhere in the program */
   private static removeUnreferencedGlobalFns(): void {
-    const referencedGlobalFns = new Set<() => any>();
-    const visitedData = new Set<Data[]>();
+    const referencedGlobalFns = new Set<GlobalFn>();
+    const visitedData = new Set<DataArray>();
+
     const findGlobalFnReferences = (envNode: EnvTreeNode): void => {
-      for (const data of Object.values(envNode.environment.head)) {
+      const headValues = Object.values(envNode.environment.head);
+      const unreferenced = setDifference(envNode.environment.heap.getHeap(), new Set(headValues));
+      for (const data of headValues) {
         if (isGlobalFn(data)) {
           referencedGlobalFns.add(data);
-        } else if (isArray(data)) {
+        } else if (isDataArray(data)) {
           findGlobalFnReferencesInData(data);
         }
       }
-      if (envNode.children) {
-        envNode.children.forEach(findGlobalFnReferences);
+      for (const data of unreferenced) {
+        // The heap will never contain a global function, unless it is the global/prelude environment
+        if (isDataArray(data)) {
+          findGlobalFnReferencesInData(data);
+        }
       }
+      envNode.children.forEach(findGlobalFnReferences);
     };
 
-    const findGlobalFnReferencesInData = (data: Data[]): void => {
+    const findGlobalFnReferencesInData = (data: DataArray): void => {
+      if (visitedData.has(data)) return;
+      visitedData.add(data);
       data.forEach(d => {
         if (isGlobalFn(d)) {
           referencedGlobalFns.add(d);
-        } else if (isArray(d) && !visitedData.has(d)) {
-          visitedData.add(d);
+        } else if (isDataArray(d)) {
           findGlobalFnReferencesInData(d);
         }
       });
     };
 
-    if (Layout.globalEnvNode.children) {
-      Layout.globalEnvNode.children.forEach(findGlobalFnReferences);
+    // First, add any referenced global functions in the stash
+    for (const item of Layout.stash.getStack()) {
+      if (isGlobalFn(item)) {
+        referencedGlobalFns.add(item);
+      } else if (isDataArray(item)) {
+        findGlobalFnReferencesInData(item);
+      }
+    }
+
+    // Then, find any references within any arrays inside the global environment heap
+    for (const data of Layout.globalEnvNode.environment.heap.getHeap()) {
+      if (isDataArray(data)) {
+        findGlobalFnReferencesInData(data);
+      }
+    }
+
+    // Finally, find any references inside the global environment children
+    Layout.globalEnvNode.children.forEach(findGlobalFnReferences);
+
+    const functionNames = new Map(
+      Object.entries(Layout.globalEnvNode.environment.head).map(([key, value]) => [value, key])
+    );
+
+    const newHead = {};
+    const newHeap = new Heap();
+    for (const fn of referencedGlobalFns) {
+      newHead[functionNames.get(fn)!] = fn;
+      if (fn.hasOwnProperty('environment')) {
+        newHeap.add(fn as Closure);
+      }
     }
 
-    const newFrame: Frame = {};
-    for (const [key, data] of Object.entries(Layout.globalEnvNode.environment.head)) {
-      if (referencedGlobalFns.has(data) || isDummyKey(key)) {
-        newFrame[key] = data;
+    // add any arrays from the original heap to the new heap
+    for (const item of Layout.globalEnvNode.environment.heap.getHeap()) {
+      if (isDataArray(item)) {
+        newHeap.add(item);
       }
     }
 
     Layout.globalEnvNode.environment.head = {
       [Config.GlobalFrameDefaultText]: Symbol(),
-      ...newFrame
+      ...newHead
     };
+    Layout.globalEnvNode.environment.heap = newHeap;
   }
 
   public static width(): number {
@@ -296,9 +358,9 @@ export class Layout {
    *  else, return the existing value */
   static createValue(data: Data, reference: ReferenceType): Value {
     if (isUnassigned(data)) {
-      return new UnassignedValue([reference]);
+      return new UnassignedValue(reference);
     } else if (isPrimitiveData(data)) {
-      return new PrimitiveValue(data, [reference]);
+      return new PrimitiveValue(data, reference);
     } else {
       // try to find if this value is already created
       const existingValue = Layout.values.get(data);
@@ -308,16 +370,22 @@ export class Layout {
       }
 
       // else create a new one
-      let newValue: Value = new PrimitiveValue(null, [reference]);
-      if (isArray(data)) {
-        newValue = new ArrayValue(data, [reference]);
+      let newValue: Value = new PrimitiveValue(null, reference);
+      if (isDataArray(data)) {
+        newValue = new ArrayValue(data, reference);
       } else if (isFunction(data)) {
-        if (isFn(data)) {
+        if (isClosure(data)) {
           // normal JS Slang function
-          newValue = new FnValue(data, [reference]);
+          newValue = new FnValue(data, reference);
         } else {
-          // function from the global env (has no extra props such as env, fnName)
-          newValue = new GlobalFnValue(data, [reference]);
+          if (reference instanceof Binding) {
+            // function from the global env (has no extra props such as env, fnName)
+            newValue = new GlobalFnValue(data, reference);
+          } else {
+            // this should be impossible, since bindings for global function always get
+            // drawn first, before any other values like arrays get drawn
+            throw new Error('First reference of global function value is not a binding!');
+          }
         }
       }
 

src/features/cseMachine/CseMachineTypes.ts

@@ -2,6 +2,7 @@ import {
   EnvTree as EnvironmentTree,
   EnvTreeNode as EnvironmentTreeNode
 } from 'js-slang/dist/createContext';
+import JsSlangClosure from 'js-slang/dist/interpreter/closure';
 import { Environment } from 'js-slang/dist/types';
 import { KonvaEventObject } from 'konva/lib/Node';
 import React from 'react';
@@ -41,33 +42,28 @@ export interface IVisible extends Drawable {
 }
 
 /** unassigned is internally represented as a symbol */
-export type UnassignedData = symbol;
+export type Unassigned = symbol;
 
 /** types of primitives in JS Slang  */
-export type PrimitiveTypes = number | string | boolean | null | undefined;
+export type Primitive = number | string | boolean | null | undefined;
 
-/** types of functions in JS Slang */
-export type FnTypes = {
-  /** the function itself */
-  (): any;
-
-  /** the enclosing environment */
-  environment: Environment;
+/** types of in-built functions in JS Slang */
+export type GlobalFn = Function;
 
-  /** string representation of the function */
-  functionName: string;
-
-  /** unique id of the function */
-  id: string;
+/** types of functions in JS Slang */
+export type Closure = JsSlangClosure;
 
-  node: any;
+/** types of arrays in JS Slang */
+export type DataArray = Data[] & {
+  readonly id: string;
+  environment: Env;
 };
 
 /** the types of data in the JS Slang context */
-export type Data = PrimitiveTypes | FnTypes | (() => any) | UnassignedData | Data[];
+export type Data = Primitive | Closure | GlobalFn | Unassigned | DataArray;
 
 /** modified `Environment` to store children and associated frame */
-export type Env = Environment | null;
+export type Env = Environment;
 
 /** modified `EnvTree` */
 export type EnvTree = EnvironmentTree & { root: EnvTreeNode };