Merge pull request #1385 from informalsystems/1298/immutable-transform

Ensure transformations can't mutate the original object

Author: Shon Feder

quint/package-lock.json

@@ -2,13 +2,7 @@
   "name": "@informalsystems/quint",
   "version": "0.18.3",
   "description": "Core tool for the Quint specification language",
-  "keywords": [
-    "temporal",
-    "logic",
-    "formal",
-    "specification",
-    "verification"
-  ],
+  "keywords": ["temporal", "logic", "formal", "specification", "verification"],
   "homepage": "https://github.com/informalsystems/quint",
   "bugs": "https://github.com/informalsystems/quint/issues",
   "license": "Apache 2.0",
@@ -35,11 +29,7 @@
   "bin": {
     "quint": "dist/src/cli.js"
   },
-  "files": [
-    "README.md",
-    "dist/**/*",
-    "test/**/*.ts"
-  ],
+  "files": ["README.md", "dist/**/*", "test/**/*.ts"],
   "engines": {
     "node": "18 - 20"
   },
@@ -63,6 +53,8 @@
     "line-column": "^1.0.2",
     "lodash": "^4.17.21",
     "lodash.isequal": "^4.5.0",
+    "lodash.clonedeep": "4.5.0",
+    "@types/lodash.clonedeep": "4.5.0",
     "seedrandom": "^3.0.5",
     "tar": "^6.1.14",
     "yargs": "^17.2.1"

quint/package.json

@@ -17,6 +17,7 @@ import * as ir from './quintIr'
 import * as t from './quintTypes'
 import { unreachable } from '../util'
 import { LookupDefinition } from '../names/base'
+import cloneDeep from 'lodash.clonedeep'
 
 export class IRTransformer {
   enterModule?: (module: ir.QuintModule) => ir.QuintModule
@@ -111,7 +112,7 @@ export class IRTransformer {
  * @returns the tranformed Quint module
  */
 export function transformModule(transformer: IRTransformer, quintModule: ir.QuintModule): ir.QuintModule {
-  let newModule = { ...quintModule }
+  let newModule = cloneDeep(quintModule)
 
   if (transformer.enterModule) {
     newModule = transformer.enterModule(newModule)
@@ -136,7 +137,7 @@ export function transformModule(transformer: IRTransformer, quintModule: ir.Quin
  * @returns the transformed Quint type
  */
 export function transformType(transformer: IRTransformer, type: t.QuintType): t.QuintType {
-  let newType = { ...type }
+  let newType = cloneDeep(type)
   if (transformer.enterType) {
     newType = transformer.enterType(newType)
   }
@@ -317,7 +318,7 @@ export function transformLookupDefinition(transformer: IRTransformer, lud: Looku
  * @returns the transformed Quint definition
  */
 export function transformDeclaration(transformer: IRTransformer, decl: ir.QuintDeclaration): ir.QuintDeclaration {
-  let newDecl = { ...decl }
+  let newDecl = cloneDeep(decl)
   if (transformer.enterDecl) {
     newDecl = transformer.enterDecl(newDecl)
   }
@@ -375,7 +376,7 @@ export function transformDeclaration(transformer: IRTransformer, decl: ir.QuintD
  * @returns the transformed Quint definition
  */
 export function transformDefinition(transformer: IRTransformer, def: ir.QuintDef): ir.QuintDef {
-  let newDef = { ...def }
+  let newDef = cloneDeep(def)
   if (transformer.enterDef) {
     newDef = transformer.enterDef(newDef)
   }
@@ -450,7 +451,7 @@ export function transformDefinition(transformer: IRTransformer, def: ir.QuintDef
  * @returns the transformed Quint expression
  */
 function transformExpression(transformer: IRTransformer, expr: ir.QuintEx): ir.QuintEx {
-  let newExpr = { ...expr }
+  let newExpr = cloneDeep(expr)
   if (transformer.enterExpr) {
     newExpr = transformer.enterExpr(newExpr)
   }
@@ -542,7 +543,7 @@ function transformExpression(transformer: IRTransformer, expr: ir.QuintEx): ir.Q
  * @returns the transformed Quint row
  */
 export function transformRow(transformer: IRTransformer, row: t.Row): t.Row {
-  let newRow = row
+  let newRow = cloneDeep(row)
   if (transformer.enterRow) {
     newRow = transformer.enterRow(newRow)
   }

quint/src/ir/IRTransformer.ts

@@ -70,13 +70,13 @@ describe('inlineAliases', () => {
     const { modules } = inlineModule(quintModule)
 
     const expectedModule = dedent(`module A {
-                                  |  type T1 = (B({}) | C({}))
-                                  |  val C: (B({}) | C({})) = variant("C", Rec())
-                                  |  type T2 = (Some((B({}) | C({}))) | None({}))
-                                  |  val B: (B({}) | C({})) = variant("B", Rec())
-                                  |  def Some: ((B({}) | C({}))) => (Some((B({}) | C({}))) | None({})) = ((__SomeParam) => variant("Some", __SomeParam))
-                                  |  val None: (Some((B({}) | C({}))) | None({})) = variant("None", Rec())
-                                  |  var x: (Some((B({}) | C({}))) | None({}))
+                                  |  type T1 = (B | C)
+                                  |  val C: (B | C) = variant("C", Rec())
+                                  |  type T2 = (Some((B | C)) | None)
+                                  |  val B: (B | C) = variant("B", Rec())
+                                  |  def Some: ((B | C)) => (Some((B | C)) | None) = ((__SomeParam) => variant("Some", __SomeParam))
+                                  |  val None: (Some((B | C)) | None) = variant("None", Rec())
+                                  |  var x: (Some((B | C)) | None)
                                   |}`)
 
     assert.deepEqual(moduleToString(modules[0]), expectedModule)