fix: Make all tuples immutable for now to match puya

algorandfoundation · Oct 16, 2024 · 441eb2d · 441eb2d
1 parent f5e0a4c
commit 441eb2d
Show file tree

Hide file tree

Showing 10 changed files with 58 additions and 67 deletions.
diff --git a/scripts/generate-op-metadata.ts b/scripts/generate-op-metadata.ts
@@ -1,9 +1,8 @@
-import * as fs from 'fs'
 import { camelCase } from 'change-case'
+import * as fs from 'fs'
+import { enumerate, hasFlags } from '../src/util'
 import type { OpFunction, OpGrouping, OpOverloadedFunction } from './build-op-module'
 import { AlgoTsType, buildOpModule } from './build-op-module'
-import { enumerate, hasFlags } from '../src/util'
-import { it } from 'vitest'
 
 const opModule = buildOpModule()
 
@@ -120,7 +119,7 @@ function mapReturnType(returnTypes: AlgoTsType[]) {
   if (ptypes.length === 1) {
     return ptypes[0]
   }
-  return `new ptypes.TuplePType({items: [${ptypes.join(', ')}], immutable: true})`
+  return `new ptypes.TuplePType({items: [${ptypes.join(', ')}]})`
 }
 
 function* emitTypes() {

diff --git a/src/awst/node-factory.ts b/src/awst/node-factory.ts
@@ -201,7 +201,7 @@ const explicitNodeFactory = {
   tupleExpression(props: Omit<Props<TupleExpression>, 'wtype'>) {
     return new TupleExpression({
       ...props,
-      wtype: new WTuple({ types: props.items.map((i) => i.wtype), immutable: false }),
+      wtype: new WTuple({ types: props.items.map((i) => i.wtype), immutable: true }),
     })
   },
   methodDocumentation(props?: { description?: string | null; args?: Map<string, string>; returns?: string | null }) {

diff --git a/src/awst_build/base-visitor.ts b/src/awst_build/base-visitor.ts
@@ -514,7 +514,6 @@ export abstract class BaseVisitor implements Visitor<Expressions, NodeBuilder> {
           items: sourceType.items.map((item, index) =>
             index < targetType.items.length ? this.buildAssignmentExpressionType(targetType.items[index], item, sourceLocation) : item,
           ),
-          immutable: sourceType.immutable,
         })
       } else if (targetType instanceof ArrayPType) {
         // Narrow array literal types to array type

diff --git a/src/awst_build/eb/arc4/arrays.ts b/src/awst_build/eb/arc4/arrays.ts
@@ -142,9 +142,7 @@ class EntriesFunctionBuilder extends FunctionBuilder {
 
   call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder {
     parseFunctionArgs({ args, typeArgs, callLocation: sourceLocation, argSpec: (_) => [], genericTypeArgs: 0, funcName: 'entries' })
-    const iteratorType = IterableIteratorType.parameterise([
-      new TuplePType({ items: [uint64PType, this.arrayBuilder.ptype.elementType], immutable: true }),
-    ])
+    const iteratorType = IterableIteratorType.parameterise([new TuplePType({ items: [uint64PType, this.arrayBuilder.ptype.elementType] })])
     return new IterableIteratorExpressionBuilder(
       nodeFactory.enumeration({
         expr: this.arrayBuilder.iterate(sourceLocation),

diff --git a/src/awst_build/eb/assert-match-function-builder.ts b/src/awst_build/eb/assert-match-function-builder.ts
@@ -46,7 +46,7 @@ export class AssertMatchFunctionBuilder extends NodeBuilder {
           )
         } else if (testProperty.hasProperty('between')) {
           const range = requireInstanceBuilder(testProperty.memberAccess('between', sourceLocation)).singleEvaluation()
-          const rangePType = new TuplePType({ items: [subjectType, subjectType], immutable: true })
+          const rangePType = new TuplePType({ items: [subjectType, subjectType] })
           codeInvariant(range.resolvableToPType(rangePType), 'Between range must be of type $')
           const zeroIndex = instanceEb(nodeFactory.uInt64Constant({ value: 0n, sourceLocation }), uint64PType)
           const gte = subjectProperty

diff --git a/src/awst_build/eb/storage/box/box-map.ts b/src/awst_build/eb/storage/box/box-map.ts
@@ -171,7 +171,7 @@ class BoxMapMaybeFunctionBuilder extends BoxMapFunctionBuilderBase {
       genericTypeArgs: 0,
       argSpec: (a) => [a.required(this.keyType)],
     })
-    const type = new TuplePType({ items: [this.contentType, boolPType], immutable: true })
+    const type = new TuplePType({ items: [this.contentType, boolPType] })
 
     return instanceEb(
       nodeFactory.stateGetEx({

diff --git a/src/awst_build/eb/storage/box/box.ts b/src/awst_build/eb/storage/box/box.ts
@@ -149,7 +149,7 @@ class BoxMaybeFunctionBuilder extends FunctionBuilder {
       genericTypeArgs: 0,
       argSpec: () => [],
     })
-    const type = new TuplePType({ items: [this.contentType, boolPType], immutable: true })
+    const type = new TuplePType({ items: [this.contentType, boolPType] })
 
     return instanceEb(
       nodeFactory.stateGetEx({

diff --git a/src/awst_build/op-metadata.ts b/src/awst_build/op-metadata.ts
diff --git a/src/awst_build/ptypes/index.ts b/src/awst_build/ptypes/index.ts
@@ -468,7 +468,6 @@ export class ArrayLiteralPType extends TransientType {
 
   getTupleType(): TuplePType {
     return new TuplePType({
-      immutable: false,
       items: this.items,
     })
   }
@@ -486,10 +485,10 @@ export class TuplePType extends PType {
   readonly items: PType[]
   readonly singleton = false
   readonly immutable: boolean
-  constructor(props: { items: PType[]; immutable?: boolean }) {
+  constructor(props: { items: PType[] }) {
     super()
     this.items = props.items
-    this.immutable = props.immutable ?? true
+    this.immutable = true
   }
 
   get wtype(): WTuple {

diff --git a/src/awst_build/type-resolver.ts b/src/awst_build/type-resolver.ts
@@ -167,7 +167,6 @@ export class TypeResolver {
 
       return new TuplePType({
         items: tsType.typeArguments.map((t) => this.resolveType(t, sourceLocation)),
-        immutable: tsType.target.readonly,
       })
     }