chore: Rename abiSafe to runtimeOnly

Author: iglosiggio

src/awst_build/arc4-util.ts

@@ -161,8 +161,9 @@ export function isArc4EncodableType(ptype: PType): boolean {
   if (ptype.equals(accountPType)) return true
   if (ptype instanceof ReadonlyTuplePType) return ptype.items.every((i) => isArc4EncodableType(i))
   if (ptype instanceof MutableTuplePType) return ptype.items.every((i) => isArc4EncodableType(i))
-  if (ptype instanceof ImmutableObjectPType) return ptype.abiSafe && ptype.orderedProperties().every(([, pt]) => isArc4EncodableType(pt))
-  if (ptype instanceof MutableObjectPType) return ptype.abiSafe && ptype.orderedProperties().every(([, pt]) => isArc4EncodableType(pt))
+  if (ptype instanceof ImmutableObjectPType)
+    return !ptype.runtimeOnly && ptype.orderedProperties().every(([, pt]) => isArc4EncodableType(pt))
+  if (ptype instanceof MutableObjectPType) return !ptype.runtimeOnly && ptype.orderedProperties().every(([, pt]) => isArc4EncodableType(pt))
   if (ptype instanceof ArrayPType || ptype instanceof FixedArrayPType || ptype instanceof ReadonlyArrayPType)
     return isArc4EncodableType(ptype.elementType)
   return false
@@ -216,15 +217,15 @@ export function ptypeToArc4EncodedType(ptype: PType, sourceLocation: SourceLocat
   if (ptype instanceof MutableTuplePType)
     return new ARC4TupleType({ types: ptype.items.map((i) => ptypeToArc4EncodedType(i, sourceLocation)) })
 
-  if (ptype instanceof ImmutableObjectPType && ptype.abiSafe)
+  if (ptype instanceof ImmutableObjectPType && !ptype.runtimeOnly)
     return new ARC4StructType({
       name: ptype.alias?.name ?? ptype.name,
       module: ptype.module,
       description: ptype.description,
       fields: Object.fromEntries(ptype.orderedProperties().map(([p, pt]) => [p, ptypeToArc4EncodedType(pt, sourceLocation)])),
       frozen: true,
     })
-  if (ptype instanceof MutableObjectPType && ptype.abiSafe)
+  if (ptype instanceof MutableObjectPType && !ptype.runtimeOnly)
     return new ARC4StructType({
       name: ptype.alias?.name ?? ptype.name,
       module: ptype.module,

src/awst_build/eb/arc4/struct.ts

@@ -30,7 +30,7 @@ export class StructClassBuilder extends ClassBuilder {
       genericTypeArgs: 1,
       callLocation: sourceLocation,
       funcName: this.typeDescription,
-      argSpec: (a) => [a.required(new ImmutableObjectPType({ properties: this.ptype.instanceType.fields, abiSafe: true }))],
+      argSpec: (a) => [a.required(new ImmutableObjectPType({ properties: this.ptype.instanceType.fields, runtimeOnly: false }))],
     })
     const initialSingle = initialValues.singleEvaluation()
 

src/awst_build/eb/storage/util.ts

@@ -37,7 +37,7 @@ export function assertCanBeUsedForStorage(ptype: PType, sourceLocation?: SourceL
   if (ptype instanceof UnsupportedType || ptype instanceof TransientType) {
     throw new CodeError(`Type ${ptype} cannot be used for storage`, { sourceLocation })
   }
-  if ((ptype instanceof MutableObjectPType || ptype instanceof ImmutableObjectPType) && !ptype.abiSafe) {
+  if ((ptype instanceof MutableObjectPType || ptype instanceof ImmutableObjectPType) && ptype.runtimeOnly) {
     const ptypeName = ptype.alias?.fullName || ptype.toString()
     throw new CodeError(`Type ${ptypeName} cannot be used for storage`, { sourceLocation })
   }

src/awst_build/ptypes/arc4-types.ts

@@ -194,7 +194,7 @@ export class ARC4StructType extends ARC4EncodedType {
   }
 
   get nativeType(): MutableObjectPType {
-    return new MutableObjectPType({ properties: this.fields, abiSafe: true })
+    return new MutableObjectPType({ properties: this.fields, runtimeOnly: false })
   }
 
   get wtype(): wtypes.ARC4Struct {
@@ -639,7 +639,7 @@ export class TypedApplicationCallResponseType extends ImmutableObjectPType {
             itxn: applicationItxnType,
             returnValue,
           },
-      abiSafe: true,
+      runtimeOnly: false,
     })
     this.name = `TypedApplicationCallResponseType<${returnValue.name}>`
     this.returnValue = returnValue

src/awst_build/ptypes/index.ts

@@ -932,31 +932,31 @@ abstract class ObjectPType extends PType {
   readonly properties: Record<string, PType>
   readonly singleton = false
   readonly immutable: boolean
-  readonly abiSafe: boolean
+  readonly runtimeOnly: boolean
 
   constructor(props: {
     alias?: SymbolName | null
     properties: Record<string, PType>
     description?: string
     namePrefix: string
     immutable: boolean
-    abiSafe: boolean
+    runtimeOnly: boolean
   }) {
     super()
     this.name = `${props.namePrefix}${generateObjectHash(props.properties)}`
     this.properties = props.properties
     this.description = props.description
     this.alias = props.alias ?? null
     this.immutable = props.immutable
-    this.abiSafe = props.abiSafe
+    this.runtimeOnly = props.runtimeOnly
   }
 
   orderedProperties() {
     return Object.entries(this.properties)
   }
 
   toString(): string {
-    return `${this.abiSafe ? '' : '@runtimeOnly'}{${this.orderedProperties()
+    return `${this.runtimeOnly ? '@runtimeOnly' : ''}{${this.orderedProperties()
       .map((p) => `${this.immutable ? 'readonly ' : ''}${p[0]}:${p[1].name}`)
       .join(',')}}`
   }
@@ -976,7 +976,7 @@ export class ObjectLiteralPType extends ObjectPType {
       ...props,
       namePrefix: `ObjectLiteral`,
       immutable: false,
-      abiSafe: true,
+      runtimeOnly: false,
     })
   }
 
@@ -989,15 +989,15 @@ export class ObjectLiteralPType extends ObjectPType {
       alias: this.alias,
       properties: this.properties,
       description: this.description,
-      abiSafe: this.abiSafe,
+      runtimeOnly: this.runtimeOnly,
     })
   }
   getMutable(): MutableObjectPType {
     return new MutableObjectPType({
       alias: this.alias,
       properties: this.properties,
       description: this.description,
-      abiSafe: this.abiSafe,
+      runtimeOnly: this.runtimeOnly,
     })
   }
 
@@ -1022,7 +1022,7 @@ export class ObjectLiteralPType extends ObjectPType {
 export class ImmutableObjectPType extends ObjectPType {
   readonly [PType.IdSymbol] = 'ImmutableObjectPType'
 
-  constructor(props: { alias?: SymbolName | null; properties: Record<string, PType>; description?: string; abiSafe: boolean }) {
+  constructor(props: { alias?: SymbolName | null; properties: Record<string, PType>; description?: string; runtimeOnly: boolean }) {
     super({
       ...props,
       namePrefix: `ReadonlyObject`,
@@ -1055,7 +1055,7 @@ export class ImmutableObjectPType extends ObjectPType {
 export class MutableObjectPType extends ObjectPType {
   readonly [PType.IdSymbol] = 'MutableObjectPType'
 
-  constructor(props: { alias?: SymbolName | null; properties: Record<string, PType>; description?: string; abiSafe: boolean }) {
+  constructor(props: { alias?: SymbolName | null; properties: Record<string, PType>; description?: string; runtimeOnly: boolean }) {
     super({
       ...props,
       namePrefix: `Object`,
@@ -1077,7 +1077,7 @@ export class MutableObjectPType extends ObjectPType {
       alias: this.alias,
       properties: this.properties,
       description: this.description,
-      abiSafe: this.abiSafe,
+      runtimeOnly: this.runtimeOnly,
     })
   }
 
@@ -1866,7 +1866,7 @@ export const compiledContractType = new ImmutableObjectPType({
     localUints: uint64PType,
     localBytes: uint64PType,
   },
-  abiSafe: true,
+  runtimeOnly: false,
 })
 export const compiledLogicSigType = new ImmutableObjectPType({
   alias: new SymbolName({
@@ -1877,7 +1877,7 @@ export const compiledLogicSigType = new ImmutableObjectPType({
   properties: {
     account: accountPType,
   },
-  abiSafe: true,
+  runtimeOnly: false,
 })
 
 export const arc28EmitFunction = new LibFunctionType({

src/awst_build/type-resolver.ts

@@ -254,7 +254,7 @@ export class TypeResolver {
       if (parts.some((p) => p.equals(arc4StructBaseType))) {
         return arc4StructBaseType
       } else if (parts.every((p) => instanceOfAny(p, ImmutableObjectPType, MutableObjectPType))) {
-        return this.reflectObjectType(tsType, false, sourceLocation)
+        return this.reflectObjectType(tsType, true, sourceLocation)
       } else {
         return IntersectionPType.fromTypes(parts)
       }
@@ -301,7 +301,7 @@ export class TypeResolver {
       return this.reflectFunctionType(typeName, callSignatures, sourceLocation)
     }
     if (isObjectType(tsType)) {
-      return this.reflectObjectType(tsType, true, sourceLocation)
+      return this.reflectObjectType(tsType, false, sourceLocation)
     }
     throw new InternalError(`Cannot determine type of ${typeName}`, { sourceLocation })
   }
@@ -352,7 +352,11 @@ export class TypeResolver {
     }
   }
 
-  private reflectObjectType(tsType: ts.Type, abiSafe: boolean, sourceLocation: SourceLocation): ImmutableObjectPType | MutableObjectPType {
+  private reflectObjectType(
+    tsType: ts.Type,
+    runtimeOnly: boolean,
+    sourceLocation: SourceLocation,
+  ): ImmutableObjectPType | MutableObjectPType {
     const typeAlias = tsType.aliasSymbol ? this.getSymbolFullName(tsType.aliasSymbol, sourceLocation) : undefined
     const properties: Record<string, PType> = {}
 
@@ -383,9 +387,9 @@ export class TypeResolver {
       }
     }
     if (expectReadonly) {
-      return new ImmutableObjectPType({ alias: typeAlias, properties, description: tryGetTypeDescription(tsType), abiSafe })
+      return new ImmutableObjectPType({ alias: typeAlias, properties, description: tryGetTypeDescription(tsType), runtimeOnly })
     } else {
-      return new MutableObjectPType({ alias: typeAlias, properties, description: tryGetTypeDescription(tsType), abiSafe })
+      return new MutableObjectPType({ alias: typeAlias, properties, description: tryGetTypeDescription(tsType), runtimeOnly })
     }
   }