fix: add tests to ensure switch clauses are evaluated only when reached

package.json

@@ -72,7 +72,7 @@
   },
   "dependencies": {
     "@algorandfoundation/algorand-typescript": "^1.0.0-beta.20",
-    "@algorandfoundation/puya-ts": "^1.0.0-beta.30",
+    "@algorandfoundation/puya-ts": "^1.0.0-beta.34",
     "elliptic": "^6.5.7",
     "js-sha256": "^0.11.0",
     "js-sha3": "^0.9.3",

tests/artifacts/switch-statements/contract.algo.ts

@@ -0,0 +1,95 @@
+import type { bytes, uint64 } from '@algorandfoundation/algorand-typescript'
+import { assert, Bytes, Contract, GlobalState, Uint64 } from '@algorandfoundation/algorand-typescript'
+
+export class DemoContract extends Contract {
+  run() {
+    assert(this.test_uint64(1) === 3)
+    assert(this.test_uint64(2) === 3)
+    assert(this.test_uint64(3) === 1)
+    assert(this.test_uint64(4) === 3)
+
+    assert(this.test_break(1) === 11)
+    assert(this.test_break(2) === 12)
+    assert(this.test_break(3) === 10)
+    assert(this.test_break(4) === 14)
+    assert(this.test_break(5) === 50)
+
+    assert(this.test_bytes(Bytes('hmmm')))
+    assert(this.test_bytes(Bytes.fromHex('ff')))
+    assert(this.test_bytes(Bytes.fromBase64('ZHNmc2Rmc2Q=')))
+    assert(this.test_bytes(Bytes.fromBase32('ONSGMZ3OMJTGOZDGMRSGM===')))
+    assert(!this.test_bytes(Bytes()))
+  }
+
+  private test_uint64(x: uint64): uint64 {
+    switch (x) {
+      case 1:
+      case 2:
+      case Uint64(4):
+        return 3
+      default: {
+        return 1
+      }
+    }
+  }
+
+  private test_break(x: uint64): uint64 {
+    let i: uint64 = 10
+    switch (x) {
+      case 1:
+      case 2:
+      case Uint64(4):
+        i += x
+        break
+      case 5:
+        i *= x
+    }
+    return i
+  }
+
+  private test_bytes(x: bytes): boolean {
+    switch (x) {
+      case Bytes('hmmm'):
+      case Bytes.fromHex('Ff'):
+      case Bytes.fromBase64('ZHNmc2Rmc2Q='):
+      case Bytes.fromBase32('ONSGMZ3OMJTGOZDGMRSGM==='):
+        return true
+    }
+    return false
+  }
+
+  evalCount = GlobalState<uint64>()
+
+  private increaseEvalAndReturn(n: uint64) {
+    this.evalCount.value++
+    return n
+  }
+
+  public test_side_effects(n: uint64) {
+    this.evalCount.value = 0
+
+    switch (n) {
+      case this.increaseEvalAndReturn(n - 1):
+        break
+      case this.increaseEvalAndReturn(n):
+        break
+      case this.increaseEvalAndReturn(n + 1):
+        break
+    }
+
+    assert(this.evalCount.value === 2, 'Only two functions should be evaluated')
+  }
+
+  public test_non_trivial_termination_of_clause(n: uint64, y: uint64): uint64 {
+    switch (n) {
+      case 1:
+        if (y % 2 === 0) {
+          return y
+        } else {
+          return n
+        }
+      default:
+        return y * n
+    }
+  }
+}

tests/switch-statements.spec.ts

@@ -0,0 +1,17 @@
+import { beforeAll, describe } from 'vitest'
+import { createArc4TestFixture } from './test-fixture'
+
+describe('switch statements', () => {
+  const [test, localnetFixture] = createArc4TestFixture('tests/artifacts/switch-statements/contract.algo.ts', { DemoContract: {} })
+  beforeAll(async () => {
+    await localnetFixture.newScope()
+  })
+
+  test('runs', async ({ appClientDemoContract }) => {
+    await appClientDemoContract.send.call({ method: 'run', args: [] })
+  })
+
+  test('test_side_effects', async ({ appClientDemoContract }) => {
+    await appClientDemoContract.send.call({ method: 'test_side_effects', args: [5] })
+  })
+})

tests/test-fixture.ts

@@ -9,7 +9,7 @@ import type { AppFactory, AppFactoryDeployParams } from '@algorandfoundation/alg
 import type { AssetCreateParams } from '@algorandfoundation/algokit-utils/types/composer'
 import { nullLogger } from '@algorandfoundation/algokit-utils/types/logging'
 import type { AlgorandFixture } from '@algorandfoundation/algokit-utils/types/testing'
-import { compile, LoggingContext } from '@algorandfoundation/puya-ts'
+import { compile, CompileOptions, LoggingContext, processInputPaths } from '@algorandfoundation/puya-ts'
 import type { Use } from '@vitest/runner/types'
 import { OnApplicationComplete } from 'algosdk'
 import fs from 'fs'
@@ -237,32 +237,33 @@ async function compilePath(
   const logCtx = LoggingContext.create()
 
   return await logCtx.run(async () => {
-    await compile({
-      outputAwstJson: false,
-      outputAwst: false,
-      paths: [path],
-      outDir: tempDir.dirPath,
-      dryRun: false,
-      logLevel: 'error' as Parameters<typeof compile>[0]['logLevel'],
-      skipVersionCheck: true,
+    await compile(
+      new CompileOptions({
+        outputAwstJson: false,
+        outputAwst: false,
+        filePaths: processInputPaths({ paths: [path], outDir: tempDir.dirPath }),
+        dryRun: false,
+        logLevel: 'error' as Parameters<typeof compile>[0]['logLevel'],
+        skipVersionCheck: true,
 
-      outputSsaIr: false,
-      outputOptimizationIr: false,
-      outputDestructuredIr: false,
-      outputMemoryIr: false,
+        outputSsaIr: false,
+        outputOptimizationIr: false,
+        outputDestructuredIr: false,
+        outputMemoryIr: false,
 
-      debugLevel: 1,
-      targetAvmVersion: 10,
-      cliTemplateDefinitions: {},
-      templateVarsPrefix: 'TMPL_',
-      localsCoalescingStrategy: 'root_operand' as Parameters<typeof compile>[0]['localsCoalescingStrategy'],
+        debugLevel: 1,
+        targetAvmVersion: 10,
+        cliTemplateDefinitions: {},
+        templateVarsPrefix: 'TMPL_',
+        localsCoalescingStrategy: 'root_operand' as Parameters<typeof compile>[0]['localsCoalescingStrategy'],
 
-      outputArc32: false,
-      outputTeal: false,
-      outputSourceMap: true,
-      optimizationLevel: 0,
-      ...options,
-    })
+        outputArc32: false,
+        outputTeal: false,
+        outputSourceMap: true,
+        optimizationLevel: 0,
+        ...options,
+      }),
+    )
     for (const log of logCtx.logEvents) {
       switch (log.level) {
         case 'error':