Ensure transformations can't mutate the original object

There was some mutation happening via the transformer, which was
wreaking havoc on attempts to complete #1298.

Apparently it was also somehow leading to incorrect printing of sum
type variants. I haven't had time to investigate why, but deep cloning
the original object must be safer and it is fixing a blocking problem in
ongoing work in #1298.

Since the cases in which this causes problems are quite subtle, I havent
been able to figure out how to test this directly.

Author: Shon Feder

quint/package.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/src/ir/IRTransformer.ts

@@ -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/test/ir/IRTransformer.test.ts

@@ -1,10 +1,10 @@
 import { describe, it } from 'mocha'
 import { assert } from 'chai'
 import { buildModuleWithDecls } from '../builders/ir'
-import { QuintDeclaration, QuintDef, QuintEx, isDef } from '../../src/ir/quintIr'
+import { QuintDeclaration, QuintDef, QuintEx, isDef, QuintModule } from '../../src/ir/quintIr'
 import { moduleToString } from '../../src/ir/IRprinting'
-import { IRTransformer, transformModule } from '../../src/ir/IRTransformer'
-import { ConcreteRow, QuintType } from '../../src/ir/quintTypes'
+import { IRTransformer, transformDeclaration, transformModule } from '../../src/ir/IRTransformer'
+import { ConcreteRow, QuintType, QuintVarType } from '../../src/ir/quintTypes'
 
 const quintModule = buildModuleWithDecls([
   'var a: int',

quint/test/types/aliasInliner.test.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)