sema

package
v1.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 3, 2024 License: Apache-2.0 Imports: 21 Imported by: 12

Documentation

Index

Constants

View Source 
const (
	Int8TypeSize    uint = 1
	UInt8TypeSize   uint = 1
	Word8TypeSize   uint = 1
	Int16TypeSize   uint = 2
	UInt16TypeSize  uint = 2
	Word16TypeSize  uint = 2
	Int32TypeSize   uint = 4
	UInt32TypeSize  uint = 4
	Word32TypeSize  uint = 4
	Int64TypeSize   uint = 8
	UInt64TypeSize  uint = 8
	Word64TypeSize  uint = 8
	Fix64TypeSize   uint = 8
	UFix64TypeSize  uint = 8
	Int128TypeSize  uint = 16
	UInt128TypeSize uint = 16
	Int256TypeSize  uint = 32
	UInt256TypeSize uint = 32
)

size constants (in bytes) for fixed-width numeric types

View Source 
const (
	FunctionPurityImpure = iota
	FunctionPurityView
)
View Source 
const (
	NumberTypeName                   = "Number"
	SignedNumberTypeName             = "SignedNumber"
	IntegerTypeName                  = "Integer"
	SignedIntegerTypeName            = "SignedInteger"
	FixedSizeUnsignedIntegerTypeName = "FixedSizeUnsignedInteger"
	FixedPointTypeName               = "FixedPoint"
	SignedFixedPointTypeName         = "SignedFixedPoint"

	IntTypeName    = "Int"
	Int8TypeName   = "Int8"
	Int16TypeName  = "Int16"
	Int32TypeName  = "Int32"
	Int64TypeName  = "Int64"
	Int128TypeName = "Int128"
	Int256TypeName = "Int256"

	UIntTypeName    = "UInt"
	UInt8TypeName   = "UInt8"
	UInt16TypeName  = "UInt16"
	UInt32TypeName  = "UInt32"
	UInt64TypeName  = "UInt64"
	UInt128TypeName = "UInt128"
	UInt256TypeName = "UInt256"

	Word8TypeName   = "Word8"
	Word16TypeName  = "Word16"
	Word32TypeName  = "Word32"
	Word64TypeName  = "Word64"
	Word128TypeName = "Word128"
	Word256TypeName = "Word256"

	Fix64TypeName  = "Fix64"
	UFix64TypeName = "UFix64"
)
View Source 
const AccountCapabilityControllerTypeBorrowTypeFieldDocString = `
The type of the controlled capability, i.e. the T in ` + "`Capability<T>`" + `.
`
View Source 
const AccountCapabilityControllerTypeBorrowTypeFieldName = "borrowType"
View Source 
const AccountCapabilityControllerTypeCapabilityFieldDocString = `
The capability that is controlled by this controller.
`
View Source 
const AccountCapabilityControllerTypeCapabilityFieldName = "capability"
View Source 
const AccountCapabilityControllerTypeCapabilityIDFieldDocString = `
The identifier of the controlled capability.
All copies of a capability have the same ID.
`
View Source 
const AccountCapabilityControllerTypeCapabilityIDFieldName = "capabilityID"
View Source 
const AccountCapabilityControllerTypeDeleteFunctionDocString = `` /* 380-byte string literal not displayed */
View Source 
const AccountCapabilityControllerTypeDeleteFunctionName = "delete"
View Source 
const AccountCapabilityControllerTypeName = "AccountCapabilityController"
View Source 
const AccountCapabilityControllerTypeSetTagFunctionDocString = `
Updates this controller's tag to the provided string
`
View Source 
const AccountCapabilityControllerTypeSetTagFunctionName = "setTag"
View Source 
const AccountCapabilityControllerTypeTagFieldDocString = `` /* 131-byte string literal not displayed */
View Source 
const AccountCapabilityControllerTypeTagFieldName = "tag"
View Source 
const AccountKeyHashAlgoFieldName = "hashAlgorithm"
View Source 
const AccountKeyIsRevokedFieldName = "isRevoked"
View Source 
const AccountKeyKeyIndexFieldName = "keyIndex"
View Source 
const AccountKeyPublicKeyFieldName = "publicKey"
View Source 
const AccountKeyTypeName = "AccountKey"
View Source 
const AccountKeyWeightFieldName = "weight"
View Source 
const AccountTypeAddressFieldDocString = `
The address of the account.
`
View Source 
const AccountTypeAddressFieldName = "address"
View Source 
const AccountTypeAvailableBalanceFieldDocString = `
The FLOW balance of the default vault of this account that is available to be moved.
`
View Source 
const AccountTypeAvailableBalanceFieldName = "availableBalance"
View Source 
const AccountTypeBalanceFieldDocString = `
The FLOW balance of the default vault of this account.
`
View Source 
const AccountTypeBalanceFieldName = "balance"
View Source 
const AccountTypeCapabilitiesFieldDocString = `
The capabilities of the account.
`
View Source 
const AccountTypeCapabilitiesFieldName = "capabilities"
View Source 
const AccountTypeContractsFieldDocString = `
The contracts deployed to the account.
`
View Source 
const AccountTypeContractsFieldName = "contracts"
View Source 
const AccountTypeInboxFieldDocString = `
The inbox allows bootstrapping (sending and receiving) capabilities.
`
View Source 
const AccountTypeInboxFieldName = "inbox"
View Source 
const AccountTypeKeysFieldDocString = `
The keys assigned to the account.
`
View Source 
const AccountTypeKeysFieldName = "keys"
View Source 
const AccountTypeName = "Account"
View Source 
const AccountTypeStorageFieldDocString = `
The storage of the account.
`
View Source 
const AccountTypeStorageFieldName = "storage"
View Source 
const Account_AccountCapabilitiesTypeForEachControllerFunctionDocString = `
Iterate over all account capability controllers for all account capabilities,
passing a reference to each controller to the provided callback function.

Iteration is stopped early if the callback function returns ` + "`false`" + `.

If a new account capability controller is issued for the account,
or an existing account capability controller for the account is deleted,
then the callback must stop iteration by returning false.
Otherwise, iteration aborts.
`
View Source 
const Account_AccountCapabilitiesTypeForEachControllerFunctionName = "forEachController"
View Source 
const Account_AccountCapabilitiesTypeGetControllerFunctionDocString = `` /* 139-byte string literal not displayed */
View Source 
const Account_AccountCapabilitiesTypeGetControllerFunctionName = "getController"
View Source 
const Account_AccountCapabilitiesTypeGetControllersFunctionDocString = `
Get all capability controllers for all account capabilities.
`
View Source 
const Account_AccountCapabilitiesTypeGetControllersFunctionName = "getControllers"
View Source 
const Account_AccountCapabilitiesTypeIssueFunctionDocString = `
Issue/create a new account capability.
`
View Source 
const Account_AccountCapabilitiesTypeIssueFunctionName = "issue"
View Source 
const Account_AccountCapabilitiesTypeIssueWithTypeFunctionDocString = `
Issue/create a new account capability.
`
View Source 
const Account_AccountCapabilitiesTypeIssueWithTypeFunctionName = "issueWithType"
View Source 
const Account_AccountCapabilitiesTypeName = "AccountCapabilities"
View Source 
const Account_CapabilitiesTypeAccountFieldDocString = `
The account capabilities of the account.
`
View Source 
const Account_CapabilitiesTypeAccountFieldName = "account"
View Source 
const Account_CapabilitiesTypeBorrowFunctionDocString = `
Borrows the capability at the given public path.
Returns nil if the capability does not exist, or cannot be borrowed using the given type.
The function is equivalent to ` + "`get(path).borrow()`" + `.
`
View Source 
const Account_CapabilitiesTypeBorrowFunctionName = "borrow"
View Source 
const Account_CapabilitiesTypeExistsFunctionDocString = `
Returns true if a capability exists at the given public path.
`
View Source 
const Account_CapabilitiesTypeExistsFunctionName = "exists"
View Source 
const Account_CapabilitiesTypeGetFunctionDocString = `
Returns the capability at the given public path.
If the capability does not exist,
or if the given type is not a supertype of the capability's borrow type,
returns an "invalid" capability with ID 0 that will always fail to ` + "`check`" + ` or ` + "`borrow`" + `
`
View Source 
const Account_CapabilitiesTypeGetFunctionName = "get"
View Source 
const Account_CapabilitiesTypeName = "Capabilities"
View Source 
const Account_CapabilitiesTypePublishFunctionDocString = `
Publish the capability at the given public path.

If there is already a capability published under the given path, the program aborts.

The path must be a public path, i.e., only the domain ` + "`public`" + ` is allowed.
`
View Source 
const Account_CapabilitiesTypePublishFunctionName = "publish"
View Source 
const Account_CapabilitiesTypeStorageFieldDocString = `
The storage capabilities of the account.
`
View Source 
const Account_CapabilitiesTypeStorageFieldName = "storage"
View Source 
const Account_CapabilitiesTypeUnpublishFunctionDocString = `` /* 169-byte string literal not displayed */
View Source 
const Account_CapabilitiesTypeUnpublishFunctionName = "unpublish"
View Source 
const Account_ContractsTypeAddFunctionDocString = `
Adds the given contract to the account.

The ` + "`code`" + ` parameter is the UTF-8 encoded representation of the source code.
The code must contain exactly one contract or contract interface,
which must have the same name as the ` + "`name`" + ` parameter.

All additional arguments that are given are passed further to the initializer
of the contract that is being deployed.

The function fails if a contract/contract interface with the given name already exists in the account,
if the given code does not declare exactly one contract or contract interface,
or if the given name does not match the name of the contract/contract interface declaration in the code.

Returns the deployed contract.
`
View Source 
const Account_ContractsTypeAddFunctionName = "add"
View Source 
const Account_ContractsTypeBorrowFunctionDocString = `` /* 225-byte string literal not displayed */
View Source 
const Account_ContractsTypeBorrowFunctionName = "borrow"
View Source 
const Account_ContractsTypeGetFunctionDocString = `` /* 201-byte string literal not displayed */
View Source 
const Account_ContractsTypeGetFunctionName = "get"
View Source 
const Account_ContractsTypeName = "Contracts"
View Source 
const Account_ContractsTypeNamesFieldDocString = `
The names of all contracts deployed in the account.
`
View Source 
const Account_ContractsTypeNamesFieldName = "names"
View Source 
const Account_ContractsTypeRemoveFunctionDocString = `` /* 230-byte string literal not displayed */
View Source 
const Account_ContractsTypeRemoveFunctionName = "remove"
View Source 
const Account_ContractsTypeTryUpdateFunctionDocString = `
Updates the code for the contract/contract interface in the account,
and handle any deployment errors gracefully.

The ` + "`code`" + ` parameter is the UTF-8 encoded representation of the source code.
The code must contain exactly one contract or contract interface,
which must have the same name as the ` + "`name`" + ` parameter.

Does **not** run the initializer of the contract/contract interface again.
The contract instance in the world state stays as is.

Fails if no contract/contract interface with the given name exists in the account,
if the given code does not declare exactly one contract or contract interface,
or if the given name does not match the name of the contract/contract interface declaration in the code.

Returns the deployment result.
Result would contain the deployed contract for the updated contract, if the update was successfull.
Otherwise, the deployed contract would be nil.
`
View Source 
const Account_ContractsTypeTryUpdateFunctionName = "tryUpdate"
View Source 
const Account_ContractsTypeUpdateFunctionDocString = `
Updates the code for the contract/contract interface in the account.

The ` + "`code`" + ` parameter is the UTF-8 encoded representation of the source code.
The code must contain exactly one contract or contract interface,
which must have the same name as the ` + "`name`" + ` parameter.

Does **not** run the initializer of the contract/contract interface again.
The contract instance in the world state stays as is.

Fails if no contract/contract interface with the given name exists in the account,
if the given code does not declare exactly one contract or contract interface,
or if the given name does not match the name of the contract/contract interface declaration in the code.

Returns the deployed contract for the updated contract.
`
View Source 
const Account_ContractsTypeUpdateFunctionName = "update"
View Source 
const Account_InboxTypeClaimFunctionDocString = `
Claims a Capability previously published by the specified provider.

Returns ` + "`nil`" + ` if no Capability is published under the given name,
or if this account is not its intended recipient.

Errors if the Capability under that name does not match the provided type.
`
View Source 
const Account_InboxTypeClaimFunctionName = "claim"
View Source 
const Account_InboxTypeName = "Inbox"
View Source 
const Account_InboxTypePublishFunctionDocString = `
Publishes a new Capability under the given name,
to be claimed by the specified recipient.
`
View Source 
const Account_InboxTypePublishFunctionName = "publish"
View Source 
const Account_InboxTypeUnpublishFunctionDocString = `
Unpublishes a Capability previously published by this account.

Returns ` + "`nil`" + ` if no Capability is published under the given name.

Errors if the Capability under that name does not match the provided type.
`
View Source 
const Account_InboxTypeUnpublishFunctionName = "unpublish"
View Source 
const Account_KeysTypeAddFunctionDocString = `
Adds a new key with the given hashing algorithm and a weight.

Returns the added key.
`
View Source 
const Account_KeysTypeAddFunctionName = "add"
View Source 
const Account_KeysTypeCountFieldDocString = `
The total number of unrevoked keys in this account.
`
View Source 
const Account_KeysTypeCountFieldName = "count"
View Source 
const Account_KeysTypeForEachFunctionDocString = `
Iterate over all unrevoked keys in this account,
passing each key in turn to the provided function.

Iteration is stopped early if the function returns ` + "`false`" + `.

The order of iteration is undefined.
`
View Source 
const Account_KeysTypeForEachFunctionName = "forEach"
View Source 
const Account_KeysTypeGetFunctionDocString = `
Returns the key at the given index, if it exists, or nil otherwise.

Revoked keys are always returned, but they have ` + "`isRevoked`" + ` field set to true.
`
View Source 
const Account_KeysTypeGetFunctionName = "get"
View Source 
const Account_KeysTypeName = "Keys"
View Source 
const Account_KeysTypeRevokeFunctionDocString = `
Marks the key at the given index revoked, but does not delete it.

Returns the revoked key if it exists, or nil otherwise.
`
View Source 
const Account_KeysTypeRevokeFunctionName = "revoke"
View Source 
const Account_StorageCapabilitiesTypeForEachControllerFunctionDocString = `
Iterate over all storage capability controllers for capabilities that target this storage path,
passing a reference to each controller to the provided callback function.

Iteration is stopped early if the callback function returns ` + "`false`" + `.

If a new storage capability controller is issued for the path,
an existing storage capability controller for the path is deleted,
or a storage capability controller is retargeted from or to the path,
then the callback must stop iteration by returning false.
Otherwise, iteration aborts.
`
View Source 
const Account_StorageCapabilitiesTypeForEachControllerFunctionName = "forEachController"
View Source 
const Account_StorageCapabilitiesTypeGetControllerFunctionDocString = `` /* 155-byte string literal not displayed */
View Source 
const Account_StorageCapabilitiesTypeGetControllerFunctionName = "getController"
View Source 
const Account_StorageCapabilitiesTypeGetControllersFunctionDocString = `
Get all storage capability controllers for capabilities that target this storage path
`
View Source 
const Account_StorageCapabilitiesTypeGetControllersFunctionName = "getControllers"
View Source 
const Account_StorageCapabilitiesTypeIssueFunctionDocString = `
Issue/create a new storage capability.
`
View Source 
const Account_StorageCapabilitiesTypeIssueFunctionName = "issue"
View Source 
const Account_StorageCapabilitiesTypeIssueWithTypeFunctionDocString = `
Issue/create a new storage capability.
`
View Source 
const Account_StorageCapabilitiesTypeIssueWithTypeFunctionName = "issueWithType"
View Source 
const Account_StorageCapabilitiesTypeName = "StorageCapabilities"
View Source 
const Account_StorageTypeBorrowFunctionDocString = `
Returns a reference to an object in storage without removing it from storage.

If no object is stored under the given path, the function returns nil.
If there is an object stored, a reference is returned as an optional,
provided it can be borrowed using the given type.
If the stored object cannot be borrowed using the given type, the function panics.

The given type must not necessarily be exactly the same as the type of the borrowed object.

The path must be a storage path, i.e., only the domain ` + "`storage`" + ` is allowed
`
View Source 
const Account_StorageTypeBorrowFunctionName = "borrow"
View Source 
const Account_StorageTypeCapacityFieldDocString = `
The storage capacity of the account in bytes.
`
View Source 
const Account_StorageTypeCapacityFieldName = "capacity"
View Source 
const Account_StorageTypeCheckFunctionDocString = `
Returns true if the object in account storage under the given path satisfies the given type,
i.e. could be borrowed using the given type.

The given type must not necessarily be exactly the same as the type of the     borrowed object.

The path must be a storage path, i.e., only the domain ` + "`storage`" + ` is allowed.
`
View Source 
const Account_StorageTypeCheckFunctionName = "check"
View Source 
const Account_StorageTypeCopyFunctionDocString = `
Returns a copy of a structure stored in account storage under the given path,
without removing it from storage,
or nil if no object is stored under the given path.

If there is a structure stored, it is copied.
The structure stays stored in storage after the function returns.

The given type must be a supertype of the type of the copied structure.
If it is not, the function panics.

The given type must not necessarily be exactly the same as the type of the copied structure.

The path must be a storage path, i.e., only the domain ` + "`storage`" + ` is allowed.
`
View Source 
const Account_StorageTypeCopyFunctionName = "copy"
View Source 
const Account_StorageTypeForEachPublicFunctionDocString = `
Iterate over all the public paths of an account,
passing each path and type in turn to the provided callback function.

The callback function takes two arguments:
1. The path of the stored object
2. The runtime type of that object

Iteration is stopped early if the callback function returns ` + "`false`" + `.

The order of iteration is undefined.

If an object is stored under a new public path,
or an existing object is removed from a public path,
then the callback must stop iteration by returning false.
Otherwise, iteration aborts.
`
View Source 
const Account_StorageTypeForEachPublicFunctionName = "forEachPublic"
View Source 
const Account_StorageTypeForEachStoredFunctionDocString = `
Iterate over all the stored paths of an account,
passing each path and type in turn to the provided callback function.

The callback function takes two arguments:
1. The path of the stored object
2. The runtime type of that object

Iteration is stopped early if the callback function returns ` + "`false`" + `.

If an object is stored under a new storage path,
or an existing object is removed from a storage path,
then the callback must stop iteration by returning false.
Otherwise, iteration aborts.
`
View Source 
const Account_StorageTypeForEachStoredFunctionName = "forEachStored"
View Source 
const Account_StorageTypeLoadFunctionDocString = `
Loads an object from the account's storage which is stored under the given path,
or nil if no object is stored under the given path.

If there is an object stored,
the stored resource or structure is moved out of storage and returned as an optional.

When the function returns, the storage no longer contains an object under the given path.

The given type must be a supertype of the type of the loaded object.
If it is not, the function panics.

The given type must not necessarily be exactly the same as the type of the loaded object.

The path must be a storage path, i.e., only the domain ` + "`storage`" + ` is allowed.
`
View Source 
const Account_StorageTypeLoadFunctionName = "load"
View Source 
const Account_StorageTypeName = "Storage"
View Source 
const Account_StorageTypePublicPathsFieldDocString = `
All public paths of this account.
`
View Source 
const Account_StorageTypePublicPathsFieldName = "publicPaths"
View Source 
const Account_StorageTypeSaveFunctionDocString = `
Saves the given object into the account's storage at the given path.

Resources are moved into storage, and structures are copied.

If there is already an object stored under the given path, the program aborts.

The path must be a storage path, i.e., only the domain ` + "`storage`" + ` is allowed.
`
View Source 
const Account_StorageTypeSaveFunctionName = "save"
View Source 
const Account_StorageTypeStoragePathsFieldDocString = `
All storage paths of this account.
`
View Source 
const Account_StorageTypeStoragePathsFieldName = "storagePaths"
View Source 
const Account_StorageTypeTypeFunctionDocString = `
Reads the type of an object from the account's storage which is stored under the given path,
or nil if no object is stored under the given path.

If there is an object stored, the type of the object is returned without modifying the stored object.

The path must be a storage path, i.e., only the domain ` + "`storage`" + ` is allowed.
`
View Source 
const Account_StorageTypeTypeFunctionName = "type"
View Source 
const Account_StorageTypeUsedFieldDocString = `
The current amount of storage used by the account in bytes.
`
View Source 
const Account_StorageTypeUsedFieldName = "used"
View Source 
const AddressTypeFromBytesFunctionDocString = `
Returns an Address from the given byte array
`
View Source 
const AddressTypeFromBytesFunctionName = "fromBytes"
View Source 
const AddressTypeFromStringFunctionDocString = `
Attempts to parse an Address from the input string. Returns nil on invalid input.
`
View Source 
const AddressTypeFromStringFunctionName = "fromString"
View Source 
const AddressTypeName = "Address"
View Source 
const AddressTypeToBytesFunctionName = `toBytes`
View Source 
const AnyResourceAttachmentTypeName = "AnyResourceAttachment"
View Source 
const AnyStructAttachmentTypeName = "AnyStructAttachment"
View Source 
const ArgumentLabelNotRequired = "_"
View Source 
const ArrayTypeFilterFunctionName = "filter"
View Source 
const ArrayTypeMapFunctionName = "map"
View Source 
const ArrayTypeReverseFunctionName = "reverse"
View Source 
const ArrayTypeToConstantSizedFunctionName = "toConstantSized"
View Source 
const ArrayTypeToVariableSizedFunctionName = "toVariableSized"
View Source 
const BaseIdentifier = "base"
View Source 
const BeforeIdentifier = "before"
View Source 
const BlockTypeHeightFieldDocString = `` /* 184-byte string literal not displayed */
View Source 
const BlockTypeHeightFieldName = "height"
View Source 
const BlockTypeIdFieldDocString = `
The ID of the block.
It is essentially the hash of the block
`
View Source 
const BlockTypeIdFieldName = "id"
View Source 
const BlockTypeName = "Block"
View Source 
const BlockTypeTimestampFieldDocString = `
Consider observing blocks' status changes off-chain yourself to get a more reliable value.
`
View Source 
const BlockTypeTimestampFieldName = "timestamp"
View Source 
const BlockTypeViewFieldDocString = `` /* 275-byte string literal not displayed */
View Source 
const BlockTypeViewFieldName = "view"
View Source 
const CapabilityTypeAddressFieldName = "address"
View Source 
const CapabilityTypeBorrowFunctionName = "borrow"
View Source 
const CapabilityTypeCheckFunctionName = "check"
View Source 
const CapabilityTypeFunctionName = "CapabilityType"
View Source 
const CapabilityTypeIDFieldName = "id"
View Source 
const CharacterTypeName = "Character"
View Source 
const CharacterTypeToStringFunctionDocString = `
Returns this character as a String.
`
View Source 
const CharacterTypeToStringFunctionName = "toString"
View Source 
const CharacterTypeUtf8FieldDocString = `
The byte array of the UTF-8 encoding.
`
View Source 
const CharacterTypeUtf8FieldName = "utf8"
View Source 
const CompositeForEachAttachmentFunctionName = "forEachAttachment"
View Source 
const CompositeTypeFunctionName = "CompositeType"
View Source 
const ConstantSizedArrayTypeFunctionName = "ConstantSizedArrayType"
View Source 
const ContractAccountFieldName = "account"
View Source 
const DeployedContractTypeAddressFieldDocString = `
The address of the account where the contract is deployed at.
`
View Source 
const DeployedContractTypeAddressFieldName = "address"
View Source 
const DeployedContractTypeCodeFieldDocString = `
The code of the contract.
`
View Source 
const DeployedContractTypeCodeFieldName = "code"
View Source 
const DeployedContractTypeName = "DeployedContract"
View Source 
const DeployedContractTypeNameFieldDocString = `
The name of the contract.
`
View Source 
const DeployedContractTypeNameFieldName = "name"
View Source 
const DeployedContractTypePublicTypesFunctionDocString = `
Returns an array of ` + "`Type`" + ` objects representing all the public type declarations in this contract
(e.g. structs, resources, enums).

For example, given a contract
` + `
contract Foo {
access(all) struct Bar {...}
access(all) resource Qux {...}
}
` + `
then ` + "`.publicTypes()`" + ` will return an array equivalent to the expression ` + "`[Type<Bar>(), Type<Qux>()]`" + `
`
View Source 
const DeployedContractTypePublicTypesFunctionName = "publicTypes"
View Source 
const DeploymentResultTypeDeployedContractFieldDocString = `
The deployed contract.

If the the deployment was unsuccessfull, this will be nil.
`
View Source 
const DeploymentResultTypeDeployedContractFieldName = "deployedContract"
View Source 
const DeploymentResultTypeName = "DeploymentResult"
View Source 
const DictionaryTypeFunctionName = "DictionaryType"
View Source 
const EnumRawValueFieldName = "rawValue"
View Source 
const Fix64Factor = fixedpoint.Fix64Factor
View Source 
const Fix64Scale = fixedpoint.Fix64Scale
View Source 
const Fix64TypeMaxFractional = fixedpoint.Fix64TypeMaxFractional
View Source 
const Fix64TypeMaxInt = fixedpoint.Fix64TypeMaxInt
View Source 
const Fix64TypeMinFractional = fixedpoint.Fix64TypeMinFractional
View Source 
const Fix64TypeMinInt = fixedpoint.Fix64TypeMinInt
View Source 
const FromBigEndianBytesFunctionName = "fromBigEndianBytes"
View Source 
const FromStringFunctionName = "fromString"

fromString

View Source 
const FunctionEntryPointName = "main"
View Source 
const FunctionTypeFunctionName = "FunctionType"
View Source 
const GetTypeFunctionName = "getType"
View Source 
const HashAlgorithmDocStringKECCAK_256 = `` /* 187-byte string literal not displayed */
View Source 
const HashAlgorithmDocStringKMAC128_BLS_BLS12_381 = `` /* 546-byte string literal not displayed */
View Source 
const HashAlgorithmDocStringSHA2_256 = `
SHA2_256 is SHA-2 with a 256-bit digest (also referred to as SHA256)
`
View Source 
const HashAlgorithmDocStringSHA2_384 = `
SHA2_384 is SHA-2 with a 384-bit digest (also referred to as  SHA384)
`
View Source 
const HashAlgorithmDocStringSHA3_256 = `
SHA3_256 is SHA-3 with a 256-bit digest
`
View Source 
const HashAlgorithmDocStringSHA3_384 = `
SHA3_384 is SHA-3 with a 384-bit digest
`
View Source 
const HashAlgorithmTypeHashFunctionDocString = `
Returns the hash of the given data
`
View Source 
const HashAlgorithmTypeHashFunctionName = "hash"
View Source 
const HashAlgorithmTypeHashWithTagFunctionDocString = `
Returns the hash of the given data and tag
`
View Source 
const HashAlgorithmTypeHashWithTagFunctionName = "hashWithTag"
View Source 
const HashAlgorithmTypeName = "HashAlgorithm"
View Source 
const HashableStructTypeName = "HashableStruct"
View Source 
const IdentityMappingIdentifier string = "Identity"
View Source 
const InclusiveRangeTypeContainsFunctionName = "contains"
View Source 
const InclusiveRangeTypeEndFieldName = "end"
View Source 
const InclusiveRangeTypeFunctionName = "InclusiveRangeType"
View Source 
const InclusiveRangeTypeStartFieldName = "start"
View Source 
const InclusiveRangeTypeStepFieldName = "step"
View Source 
const IntersectionTypeFunctionName = "IntersectionType"
View Source 
const IsInstanceFunctionName = "isInstance"
View Source 
const MetaTypeAddressFieldName = "address"
View Source 
const MetaTypeContractNameFieldName = "contractName"
View Source 
const MetaTypeIdentifierFieldName = "identifier"
View Source 
const MetaTypeIsRecoveredFieldName = "isRecovered"
View Source 
const MetaTypeIsSubtypeFunctionName = "isSubtype"
View Source 
const MetaTypeName = "Type"
View Source 
const NumberTypeMaxFieldName = "max"
View Source 
const NumberTypeMinFieldName = "min"
View Source 
const NumericTypeSaturatingAddFunctionName = "saturatingAdd"
View Source 
const NumericTypeSaturatingDivideFunctionName = "saturatingDivide"
View Source 
const NumericTypeSaturatingMultiplyFunctionName = "saturatingMultiply"
View Source 
const NumericTypeSaturatingSubtractFunctionName = "saturatingSubtract"
View Source 
const OptionalTypeFunctionName = "OptionalType"
View Source 
const OptionalTypeMapFunctionName = "map"
View Source 
const PublicKeyTypeName = "PublicKey"
View Source 
const PublicKeyTypePublicKeyFieldName = "publicKey"
View Source 
const PublicKeyTypeSignAlgoFieldName = "signatureAlgorithm"
View Source 
const PublicKeyTypeVerifyFunctionName = "verify"
View Source 
const PublicKeyTypeVerifyPoPFunctionName = "verifyPoP"
View Source 
const ReferenceTypeFunctionName = "ReferenceType"
View Source 
const ResourceOwnerFieldName = "owner"
View Source 
const ResourceUUIDFieldName = "uuid"
View Source 
const ResultIdentifier = "result"
View Source 
const SelfIdentifier = "self"
View Source 
const SignatureAlgorithmDocStringBLS_BLS12_381 = `` /* 244-byte string literal not displayed */
View Source 
const SignatureAlgorithmDocStringECDSA_P256 = `
ECDSA_P256 is ECDSA on the NIST P-256 curve
`
View Source 
const SignatureAlgorithmDocStringECDSA_secp256k1 = `
ECDSA_secp256k1 is ECDSA on the secp256k1 curve
`
View Source 
const SignatureAlgorithmTypeName = "SignatureAlgorithm"
View Source 
const StorageCapabilityControllerTypeBorrowTypeFieldDocString = `
The type of the controlled capability, i.e. the T in ` + "`Capability<T>`" + `.
`
View Source 
const StorageCapabilityControllerTypeBorrowTypeFieldName = "borrowType"
View Source 
const StorageCapabilityControllerTypeCapabilityFieldDocString = `
The capability that is controlled by this controller.
`
View Source 
const StorageCapabilityControllerTypeCapabilityFieldName = "capability"
View Source 
const StorageCapabilityControllerTypeCapabilityIDFieldDocString = `
The identifier of the controlled capability.
All copies of a capability have the same ID.
`
View Source 
const StorageCapabilityControllerTypeCapabilityIDFieldName = "capabilityID"
View Source 
const StorageCapabilityControllerTypeDeleteFunctionDocString = `` /* 380-byte string literal not displayed */
View Source 
const StorageCapabilityControllerTypeDeleteFunctionName = "delete"
View Source 
const StorageCapabilityControllerTypeName = "StorageCapabilityController"
View Source 
const StorageCapabilityControllerTypeRetargetFunctionDocString = `
Retarget the controlled capability to the given storage path.
The path may be different or the same as the current path.
`
View Source 
const StorageCapabilityControllerTypeRetargetFunctionName = "retarget"
View Source 
const StorageCapabilityControllerTypeSetTagFunctionDocString = `
Updates this controller's tag to the provided string
`
View Source 
const StorageCapabilityControllerTypeSetTagFunctionName = "setTag"
View Source 
const StorageCapabilityControllerTypeTagFieldDocString = `` /* 131-byte string literal not displayed */
View Source 
const StorageCapabilityControllerTypeTagFieldName = "tag"
View Source 
const StorageCapabilityControllerTypeTargetFunctionDocString = `
Returns the targeted storage path of the controlled capability.
`
View Source 
const StorageCapabilityControllerTypeTargetFunctionName = "target"
View Source 
const StringTypeConcatFunctionName = "concat"
View Source 
const StringTypeContainsFunctionName = "contains"
View Source 
const StringTypeCountFunctionName = "count"
View Source 
const StringTypeDecodeHexFunctionName = "decodeHex"
View Source 
const StringTypeEncodeHexFunctionDocString = `
Returns a hexadecimal string for the given byte array
`
View Source 
const StringTypeEncodeHexFunctionName = "encodeHex"
View Source 
const StringTypeFromCharactersFunctionDocString = `
Returns a string from the given array of characters
`
View Source 
const StringTypeFromCharactersFunctionName = "fromCharacters"
View Source 
const StringTypeFromUtf8FunctionDocString = `
Attempt to decode the input as a UTF-8 encoded string. Returns nil if the input bytes are malformed UTF-8
`
View Source 
const StringTypeFromUtf8FunctionName = "fromUTF8"
View Source 
const StringTypeIndexFunctionName = "index"
View Source 
const StringTypeJoinFunctionDocString = `
Returns a string after joining the array of strings with the provided separator.
`
View Source 
const StringTypeJoinFunctionName = "join"
View Source 
const StringTypeLengthFieldName = "length"
View Source 
const StringTypeReplaceAllFunctionDocString = `
Returns a new string after replacing all the occurrences of parameter ` + "`of` with the parameter `with`" + `.

If ` + "`with`" + ` is empty, it matches at the beginning of the string and after each UTF-8 sequence, yielding k+1 replacements for a string of length k.
`
View Source 
const StringTypeReplaceAllFunctionName = "replaceAll"
View Source 
const StringTypeSliceFunctionName = "slice"
View Source 
const StringTypeSplitFunctionDocString = `
Returns a variable-sized array of strings after splitting the string on the delimiter.
`
View Source 
const StringTypeSplitFunctionName = "split"
View Source 
const StringTypeToLowerFunctionName = "toLower"
View Source 
const StringTypeUtf8FieldName = "utf8"
View Source 
const StructStringerTypeName = "StructStringer"
View Source 
const StructStringerTypeToStringFunctionDocString = `
Returns the string representation of this object.
`
View Source 
const StructStringerTypeToStringFunctionName = "toString"
View Source 
const ToBigEndianBytesFunctionName = "toBigEndianBytes"
View Source 
const ToStringFunctionName = "toString"
View Source 
const TypeIDSeparator = '.'
View Source 
const UFix64TypeMaxFractional = fixedpoint.UFix64TypeMaxFractional
View Source 
const UFix64TypeMaxInt = fixedpoint.UFix64TypeMaxInt
View Source 
const UFix64TypeMinFractional = fixedpoint.UFix64TypeMinFractional
View Source 
const UFix64TypeMinInt = fixedpoint.UFix64TypeMinInt
View Source 
const VariableSizedArrayTypeFunctionName = "VariableSizedArrayType"

Variables

View Source 
var (

	// NumberType represents the super-type of all number types
	NumberType = NewNumericType(NumberTypeName).
				WithTag(NumberTypeTag).
				AsSuperType()

	NumberTypeAnnotation = NewTypeAnnotation(NumberType)

	// SignedNumberType represents the super-type of all signed number types
	SignedNumberType = NewNumericType(SignedNumberTypeName).
						WithTag(SignedNumberTypeTag).
						AsSuperType()

	SignedNumberTypeAnnotation = NewTypeAnnotation(SignedNumberType)

	// IntegerType represents the super-type of all integer types
	IntegerType = NewNumericType(IntegerTypeName).
				WithTag(IntegerTypeTag).
				AsSuperType()

	IntegerTypeAnnotation = NewTypeAnnotation(IntegerType)

	// SignedIntegerType represents the super-type of all signed integer types
	SignedIntegerType = NewNumericType(SignedIntegerTypeName).
						WithTag(SignedIntegerTypeTag).
						AsSuperType()

	SignedIntegerTypeAnnotation = NewTypeAnnotation(SignedIntegerType)

	// FixedSizeUnsignedIntegerType represents the super-type of all unsigned integer types which have a fixed size.
	FixedSizeUnsignedIntegerType = NewNumericType(FixedSizeUnsignedIntegerTypeName).
									WithTag(FixedSizeUnsignedIntegerTypeTag).
									AsSuperType()

	// IntType represents the arbitrary-precision integer type `Int`
	IntType = NewNumericType(IntTypeName).
			WithTag(IntTypeTag)

	IntTypeAnnotation = NewTypeAnnotation(IntType)

	// Int8Type represents the 8-bit signed integer type `Int8`
	Int8Type = NewNumericType(Int8TypeName).
				WithTag(Int8TypeTag).
				WithIntRange(Int8TypeMinInt, Int8TypeMaxInt).
				WithByteSize(1).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
			Divide:   true,
		})

	Int8TypeAnnotation = NewTypeAnnotation(Int8Type)

	// Int16Type represents the 16-bit signed integer type `Int16`
	Int16Type = NewNumericType(Int16TypeName).
				WithTag(Int16TypeTag).
				WithIntRange(Int16TypeMinInt, Int16TypeMaxInt).
				WithByteSize(2).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
			Divide:   true,
		})

	Int16TypeAnnotation = NewTypeAnnotation(Int16Type)

	// Int32Type represents the 32-bit signed integer type `Int32`
	Int32Type = NewNumericType(Int32TypeName).
				WithTag(Int32TypeTag).
				WithIntRange(Int32TypeMinInt, Int32TypeMaxInt).
				WithByteSize(4).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
			Divide:   true,
		})

	Int32TypeAnnotation = NewTypeAnnotation(Int32Type)

	// Int64Type represents the 64-bit signed integer type `Int64`
	Int64Type = NewNumericType(Int64TypeName).
				WithTag(Int64TypeTag).
				WithIntRange(Int64TypeMinInt, Int64TypeMaxInt).
				WithByteSize(8).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
			Divide:   true,
		})

	Int64TypeAnnotation = NewTypeAnnotation(Int64Type)

	// Int128Type represents the 128-bit signed integer type `Int128`
	Int128Type = NewNumericType(Int128TypeName).
				WithTag(Int128TypeTag).
				WithIntRange(Int128TypeMinIntBig, Int128TypeMaxIntBig).
				WithByteSize(16).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
			Divide:   true,
		})

	Int128TypeAnnotation = NewTypeAnnotation(Int128Type)

	// Int256Type represents the 256-bit signed integer type `Int256`
	Int256Type = NewNumericType(Int256TypeName).
				WithTag(Int256TypeTag).
				WithIntRange(Int256TypeMinIntBig, Int256TypeMaxIntBig).
				WithByteSize(32).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
			Divide:   true,
		})

	Int256TypeAnnotation = NewTypeAnnotation(Int256Type)

	// UIntType represents the arbitrary-precision unsigned integer type `UInt`
	UIntType = NewNumericType(UIntTypeName).
				WithTag(UIntTypeTag).
				WithIntRange(UIntTypeMin, nil).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Subtract: true,
		})

	UIntTypeAnnotation = NewTypeAnnotation(UIntType)

	// UInt8Type represents the 8-bit unsigned integer type `UInt8`
	// which checks for overflow and underflow
	UInt8Type = NewNumericType(UInt8TypeName).
				WithTag(UInt8TypeTag).
				WithIntRange(UInt8TypeMinInt, UInt8TypeMaxInt).
				WithByteSize(1).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
		})

	UInt8TypeAnnotation = NewTypeAnnotation(UInt8Type)

	// UInt16Type represents the 16-bit unsigned integer type `UInt16`
	// which checks for overflow and underflow
	UInt16Type = NewNumericType(UInt16TypeName).
				WithTag(UInt16TypeTag).
				WithIntRange(UInt16TypeMinInt, UInt16TypeMaxInt).
				WithByteSize(2).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
		})

	UInt16TypeAnnotation = NewTypeAnnotation(UInt16Type)

	// UInt32Type represents the 32-bit unsigned integer type `UInt32`
	// which checks for overflow and underflow
	UInt32Type = NewNumericType(UInt32TypeName).
				WithTag(UInt32TypeTag).
				WithIntRange(UInt32TypeMinInt, UInt32TypeMaxInt).
				WithByteSize(4).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
		})

	UInt32TypeAnnotation = NewTypeAnnotation(UInt32Type)

	// UInt64Type represents the 64-bit unsigned integer type `UInt64`
	// which checks for overflow and underflow
	UInt64Type = NewNumericType(UInt64TypeName).
				WithTag(UInt64TypeTag).
				WithIntRange(UInt64TypeMinInt, UInt64TypeMaxInt).
				WithByteSize(8).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
		})

	UInt64TypeAnnotation = NewTypeAnnotation(UInt64Type)

	// UInt128Type represents the 128-bit unsigned integer type `UInt128`
	// which checks for overflow and underflow
	UInt128Type = NewNumericType(UInt128TypeName).
				WithTag(UInt128TypeTag).
				WithIntRange(UInt128TypeMinIntBig, UInt128TypeMaxIntBig).
				WithByteSize(16).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
		})

	UInt128TypeAnnotation = NewTypeAnnotation(UInt128Type)

	// UInt256Type represents the 256-bit unsigned integer type `UInt256`
	// which checks for overflow and underflow
	UInt256Type = NewNumericType(UInt256TypeName).
				WithTag(UInt256TypeTag).
				WithIntRange(UInt256TypeMinIntBig, UInt256TypeMaxIntBig).
				WithByteSize(32).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
		})

	UInt256TypeAnnotation = NewTypeAnnotation(UInt256Type)

	// Word8Type represents the 8-bit unsigned integer type `Word8`
	// which does NOT check for overflow and underflow
	Word8Type = NewNumericType(Word8TypeName).
				WithTag(Word8TypeTag).
				WithByteSize(1).
				WithIntRange(Word8TypeMinInt, Word8TypeMaxInt)

	Word8TypeAnnotation = NewTypeAnnotation(Word8Type)

	// Word16Type represents the 16-bit unsigned integer type `Word16`
	// which does NOT check for overflow and underflow
	Word16Type = NewNumericType(Word16TypeName).
				WithTag(Word16TypeTag).
				WithByteSize(2).
				WithIntRange(Word16TypeMinInt, Word16TypeMaxInt)

	Word16TypeAnnotation = NewTypeAnnotation(Word16Type)

	// Word32Type represents the 32-bit unsigned integer type `Word32`
	// which does NOT check for overflow and underflow
	Word32Type = NewNumericType(Word32TypeName).
				WithTag(Word32TypeTag).
				WithByteSize(4).
				WithIntRange(Word32TypeMinInt, Word32TypeMaxInt)

	Word32TypeAnnotation = NewTypeAnnotation(Word32Type)

	// Word64Type represents the 64-bit unsigned integer type `Word64`
	// which does NOT check for overflow and underflow
	Word64Type = NewNumericType(Word64TypeName).
				WithTag(Word64TypeTag).
				WithByteSize(8).
				WithIntRange(Word64TypeMinInt, Word64TypeMaxInt)

	Word64TypeAnnotation = NewTypeAnnotation(Word64Type)

	// Word128Type represents the 128-bit unsigned integer type `Word128`
	// which does NOT check for overflow and underflow
	Word128Type = NewNumericType(Word128TypeName).
				WithTag(Word128TypeTag).
				WithByteSize(16).
				WithIntRange(Word128TypeMinIntBig, Word128TypeMaxIntBig)

	Word128TypeAnnotation = NewTypeAnnotation(Word128Type)

	// Word256Type represents the 256-bit unsigned integer type `Word256`
	// which does NOT check for overflow and underflow
	Word256Type = NewNumericType(Word256TypeName).
				WithTag(Word256TypeTag).
				WithByteSize(32).
				WithIntRange(Word256TypeMinIntBig, Word256TypeMaxIntBig)

	Word256TypeAnnotation = NewTypeAnnotation(Word256Type)

	// FixedPointType represents the super-type of all fixed-point types
	FixedPointType = NewNumericType(FixedPointTypeName).
					WithTag(FixedPointTypeTag).
					AsSuperType()

	FixedPointTypeAnnotation = NewTypeAnnotation(FixedPointType)

	// SignedFixedPointType represents the super-type of all signed fixed-point types
	SignedFixedPointType = NewNumericType(SignedFixedPointTypeName).
							WithTag(SignedFixedPointTypeTag).
							AsSuperType()

	SignedFixedPointTypeAnnotation = NewTypeAnnotation(SignedFixedPointType)

	// Fix64Type represents the 64-bit signed decimal fixed-point type `Fix64`
	// which has a scale of Fix64Scale, and checks for overflow and underflow
	Fix64Type = NewFixedPointNumericType(Fix64TypeName).
				WithTag(Fix64TypeTag).
				WithIntRange(Fix64TypeMinIntBig, Fix64TypeMaxIntBig).
				WithFractionalRange(Fix64TypeMinFractionalBig, Fix64TypeMaxFractionalBig).
				WithScale(Fix64Scale).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
			Divide:   true,
		})

	Fix64TypeAnnotation = NewTypeAnnotation(Fix64Type)

	// UFix64Type represents the 64-bit unsigned decimal fixed-point type `UFix64`
	// which has a scale of 1E9, and checks for overflow and underflow
	UFix64Type = NewFixedPointNumericType(UFix64TypeName).
				WithTag(UFix64TypeTag).
				WithIntRange(UFix64TypeMinIntBig, UFix64TypeMaxIntBig).
				WithFractionalRange(UFix64TypeMinFractionalBig, UFix64TypeMaxFractionalBig).
				WithScale(Fix64Scale).
				WithSaturatingFunctions(SaturatingArithmeticSupport{
			Add:      true,
			Subtract: true,
			Multiply: true,
		})

	UFix64TypeAnnotation = NewTypeAnnotation(UFix64Type)
)
View Source 
var (
	Int8TypeMinInt = new(big.Int).SetInt64(math.MinInt8)
	Int8TypeMaxInt = new(big.Int).SetInt64(math.MaxInt8)

	Int16TypeMinInt = new(big.Int).SetInt64(math.MinInt16)
	Int16TypeMaxInt = new(big.Int).SetInt64(math.MaxInt16)

	Int32TypeMinInt = new(big.Int).SetInt64(math.MinInt32)
	Int32TypeMaxInt = new(big.Int).SetInt64(math.MaxInt32)

	Int64TypeMinInt = new(big.Int).SetInt64(math.MinInt64)
	Int64TypeMaxInt = new(big.Int).SetInt64(math.MaxInt64)

	Int128TypeMinIntBig = func() *big.Int {
		int128TypeMin := big.NewInt(-1)
		int128TypeMin.Lsh(int128TypeMin, 127)
		return int128TypeMin
	}()

	Int128TypeMaxIntBig = func() *big.Int {
		int128TypeMax := big.NewInt(1)
		int128TypeMax.Lsh(int128TypeMax, 127)
		int128TypeMax.Sub(int128TypeMax, big.NewInt(1))
		return int128TypeMax
	}()

	Int256TypeMinIntBig = func() *big.Int {
		int256TypeMin := big.NewInt(-1)
		int256TypeMin.Lsh(int256TypeMin, 255)
		return int256TypeMin
	}()

	Int256TypeMaxIntBig = func() *big.Int {
		int256TypeMax := big.NewInt(1)
		int256TypeMax.Lsh(int256TypeMax, 255)
		int256TypeMax.Sub(int256TypeMax, big.NewInt(1))
		return int256TypeMax
	}()

	UIntTypeMin = new(big.Int)

	UInt8TypeMinInt = new(big.Int)
	UInt8TypeMaxInt = new(big.Int).SetUint64(math.MaxUint8)

	UInt16TypeMinInt = new(big.Int)
	UInt16TypeMaxInt = new(big.Int).SetUint64(math.MaxUint16)

	UInt32TypeMinInt = new(big.Int)
	UInt32TypeMaxInt = new(big.Int).SetUint64(math.MaxUint32)

	UInt64TypeMinInt = new(big.Int)
	UInt64TypeMaxInt = new(big.Int).SetUint64(math.MaxUint64)

	UInt128TypeMinIntBig = new(big.Int)

	UInt128TypeMaxIntBig = func() *big.Int {
		uInt128TypeMax := big.NewInt(1)
		uInt128TypeMax.Lsh(uInt128TypeMax, 128)
		uInt128TypeMax.Sub(uInt128TypeMax, big.NewInt(1))
		return uInt128TypeMax

	}()

	UInt256TypeMinIntBig = new(big.Int)

	UInt256TypeMaxIntBig = func() *big.Int {
		uInt256TypeMax := big.NewInt(1)
		uInt256TypeMax.Lsh(uInt256TypeMax, 256)
		uInt256TypeMax.Sub(uInt256TypeMax, big.NewInt(1))
		return uInt256TypeMax
	}()

	Word8TypeMinInt = new(big.Int)
	Word8TypeMaxInt = new(big.Int).SetUint64(math.MaxUint8)

	Word16TypeMinInt = new(big.Int)
	Word16TypeMaxInt = new(big.Int).SetUint64(math.MaxUint16)

	Word32TypeMinInt = new(big.Int)
	Word32TypeMaxInt = new(big.Int).SetUint64(math.MaxUint32)

	Word64TypeMinInt = new(big.Int)
	Word64TypeMaxInt = new(big.Int).SetUint64(math.MaxUint64)

	// 1 << 128
	Word128TypeMaxIntPlusOneBig = func() *big.Int {
		word128TypeMaxPlusOne := big.NewInt(1)
		word128TypeMaxPlusOne.Lsh(word128TypeMaxPlusOne, 128)
		return word128TypeMaxPlusOne
	}()
	Word128TypeMinIntBig = new(big.Int)
	Word128TypeMaxIntBig = func() *big.Int {
		word128TypeMax := new(big.Int)
		word128TypeMax.Sub(Word128TypeMaxIntPlusOneBig, big.NewInt(1))
		return word128TypeMax
	}()

	// 1 << 256
	Word256TypeMaxIntPlusOneBig = func() *big.Int {
		word256TypeMaxPlusOne := big.NewInt(1)
		word256TypeMaxPlusOne.Lsh(word256TypeMaxPlusOne, 256)
		return word256TypeMaxPlusOne
	}()
	Word256TypeMinIntBig = new(big.Int)
	Word256TypeMaxIntBig = func() *big.Int {
		word256TypeMax := new(big.Int)
		word256TypeMax.Sub(Word256TypeMaxIntPlusOneBig, big.NewInt(1))
		return word256TypeMax
	}()

	Fix64FactorBig = new(big.Int).SetUint64(uint64(Fix64Factor))

	Fix64TypeMinIntBig = fixedpoint.Fix64TypeMinIntBig
	Fix64TypeMaxIntBig = fixedpoint.Fix64TypeMaxIntBig

	Fix64TypeMinFractionalBig = fixedpoint.Fix64TypeMinFractionalBig
	Fix64TypeMaxFractionalBig = fixedpoint.Fix64TypeMaxFractionalBig

	UFix64TypeMinIntBig = fixedpoint.UFix64TypeMinIntBig
	UFix64TypeMaxIntBig = fixedpoint.UFix64TypeMaxIntBig

	UFix64TypeMinFractionalBig = fixedpoint.UFix64TypeMinFractionalBig
	UFix64TypeMaxFractionalBig = fixedpoint.UFix64TypeMaxFractionalBig
)

Numeric type ranges

View Source 
var (
	// NoTypeTag is a special tag to represent mask with no types included
	NoTypeTag = newTypeTagFromLowerMask(noTypeMask)

	SignedIntegerTypeTag = newTypeTagFromLowerMask(signedIntegerTypeMask).
							Or(IntTypeTag).
							Or(Int8TypeTag).
							Or(Int16TypeTag).
							Or(Int32TypeTag).
							Or(Int64TypeTag).
							Or(Int128TypeTag).
							Or(Int256TypeTag)

	FixedSizeUnsignedIntegerTypeTag = newTypeTagFromUpperMask(fixedSizeUnsignedIntegerTypeMask).
									Or(UInt8TypeTag).
									Or(UInt16TypeTag).
									Or(UInt32TypeTag).
									Or(UInt64TypeTag).
									Or(UInt128TypeTag).
									Or(UInt256TypeTag).
									Or(Word8TypeTag).
									Or(Word16TypeTag).
									Or(Word32TypeTag).
									Or(Word64TypeTag).
									Or(Word128TypeTag).
									Or(Word256TypeTag)

	UnsignedIntegerTypeTag = newTypeTagFromLowerMask(unsignedIntegerTypeMask).
							Or(UIntTypeTag).
							Or(FixedSizeUnsignedIntegerTypeTag)

	IntegerTypeTag = newTypeTagFromLowerMask(integerTypeMask).
					Or(SignedIntegerTypeTag).
					Or(UnsignedIntegerTypeTag)

	SignedFixedPointTypeTag = newTypeTagFromLowerMask(signedFixedPointTypeMask).
							Or(Fix64TypeTag)

	UnsignedFixedPointTypeTag = newTypeTagFromLowerMask(unsignedFixedPointTypeMask).
								Or(UFix64TypeTag)

	FixedPointTypeTag = newTypeTagFromLowerMask(fixedPointTypeMask).
						Or(SignedFixedPointTypeTag).
						Or(UnsignedFixedPointTypeTag)

	SignedNumberTypeTag = newTypeTagFromLowerMask(signedNumberTypeMask).
						Or(SignedIntegerTypeTag).
						Or(SignedFixedPointTypeTag)

	NumberTypeTag = newTypeTagFromLowerMask(numberTypeMask).
					Or(IntegerTypeTag).
					Or(FixedPointTypeTag).
					Or(SignedNumberTypeTag)

	UIntTypeTag    = newTypeTagFromLowerMask(uintTypeMask)
	UInt8TypeTag   = newTypeTagFromLowerMask(uint8TypeMask)
	UInt16TypeTag  = newTypeTagFromLowerMask(uint16TypeMask)
	UInt32TypeTag  = newTypeTagFromLowerMask(uint32TypeMask)
	UInt64TypeTag  = newTypeTagFromLowerMask(uint64TypeMask)
	UInt128TypeTag = newTypeTagFromLowerMask(uint128TypeMask)
	UInt256TypeTag = newTypeTagFromLowerMask(uint256TypeMask)

	IntTypeTag    = newTypeTagFromLowerMask(intTypeMask)
	Int8TypeTag   = newTypeTagFromLowerMask(int8TypeMask)
	Int16TypeTag  = newTypeTagFromLowerMask(int16TypeMask)
	Int32TypeTag  = newTypeTagFromLowerMask(int32TypeMask)
	Int64TypeTag  = newTypeTagFromLowerMask(int64TypeMask)
	Int128TypeTag = newTypeTagFromLowerMask(int128TypeMask)
	Int256TypeTag = newTypeTagFromLowerMask(int256TypeMask)

	Word8TypeTag   = newTypeTagFromLowerMask(word8TypeMask)
	Word16TypeTag  = newTypeTagFromLowerMask(word16TypeMask)
	Word32TypeTag  = newTypeTagFromLowerMask(word32TypeMask)
	Word64TypeTag  = newTypeTagFromLowerMask(word64TypeMask)
	Word128TypeTag = newTypeTagFromLowerMask(word128TypeMask)
	Word256TypeTag = newTypeTagFromLowerMask(word256TypeMask)

	Fix64TypeTag  = newTypeTagFromLowerMask(fix64TypeMask)
	UFix64TypeTag = newTypeTagFromLowerMask(ufix64TypeMask)

	StringTypeTag           = newTypeTagFromLowerMask(stringTypeMask)
	CharacterTypeTag        = newTypeTagFromLowerMask(characterTypeMask)
	BoolTypeTag             = newTypeTagFromLowerMask(boolTypeMask)
	NilTypeTag              = newTypeTagFromLowerMask(nilTypeMask)
	VoidTypeTag             = newTypeTagFromLowerMask(voidTypeMask)
	AddressTypeTag          = newTypeTagFromLowerMask(addressTypeMask)
	MetaTypeTag             = newTypeTagFromLowerMask(metaTypeMask)
	NeverTypeTag            = newTypeTagFromLowerMask(neverTypeMask)
	BlockTypeTag            = newTypeTagFromLowerMask(blockTypeMask)
	DeployedContractTypeTag = newTypeTagFromLowerMask(deployedContractMask)

	StoragePathTypeTag = newTypeTagFromLowerMask(storagePathTypeMask)
	PublicPathTypeTag  = newTypeTagFromLowerMask(publicPathTypeMask)
	PrivatePathTypeTag = newTypeTagFromLowerMask(privatePathTypeMask)

	CapabilityPathTypeTag = newTypeTagFromLowerMask(capabilityPathTypeMask).
							Or(PublicPathTypeTag).
							Or(PrivatePathTypeTag)

	PathTypeTag = newTypeTagFromLowerMask(pathTypeMask).
				Or(CapabilityPathTypeTag).
				Or(StoragePathTypeTag)

	ConstantSizedTypeTag = newTypeTagFromLowerMask(constantSizedTypeMask)
	VariableSizedTypeTag = newTypeTagFromLowerMask(variableSizedTypeMask)
	DictionaryTypeTag    = newTypeTagFromLowerMask(dictionaryTypeMask)
	CompositeTypeTag     = newTypeTagFromLowerMask(compositeTypeMask)
	ReferenceTypeTag     = newTypeTagFromLowerMask(referenceTypeMask)
	GenericTypeTag       = newTypeTagFromLowerMask(genericTypeMask)
	FunctionTypeTag      = newTypeTagFromUpperMask(functionTypeMask)
	InterfaceTypeTag     = newTypeTagFromUpperMask(interfaceTypeMask)

	IntersectionTypeTag                = newTypeTagFromUpperMask(intersectionTypeMask)
	CapabilityTypeTag                  = newTypeTagFromUpperMask(capabilityTypeMask)
	InclusiveRangeTypeTag              = newTypeTagFromUpperMask(inclusiveRangeTypeMask)
	InvalidTypeTag                     = newTypeTagFromUpperMask(invalidTypeMask)
	TransactionTypeTag                 = newTypeTagFromUpperMask(transactionTypeMask)
	AnyResourceAttachmentTypeTag       = newTypeTagFromUpperMask(anyResourceAttachmentMask)
	AnyStructAttachmentTypeTag         = newTypeTagFromUpperMask(anyStructAttachmentMask)
	StorageCapabilityControllerTypeTag = newTypeTagFromUpperMask(storageCapabilityControllerTypeMask)
	AccountCapabilityControllerTypeTag = newTypeTagFromUpperMask(accountCapabilityControllerTypeMask)

	HashableStructTypeTag = newTypeTagFromUpperMask(hashableStructMask).
							Or(AddressTypeTag).
							Or(NeverTypeTag).
							Or(BoolTypeTag).
							Or(CharacterTypeTag).
							Or(StringTypeTag).
							Or(MetaTypeTag).
							Or(NumberTypeTag).
							Or(PathTypeTag)

	// AnyStructTypeTag only includes the types that are pre-known
	// to belong to AnyStruct type. This is more of an optimization.
	// Other types (derived types such as collections, etc.) are not possible
	// to be included in the mask without knowing their member types.
	// Hence, they are checked on demand in `getSuperTypeOfDerivedTypes()`.
	AnyStructTypeTag = newTypeTagFromLowerMask(anyStructTypeMask).
						Or(AnyStructAttachmentTypeTag).
						Or(NeverTypeTag).
						Or(NumberTypeTag).
						Or(StringTypeTag).
						Or(ReferenceTypeTag).
						Or(NilTypeTag).
						Or(BoolTypeTag).
						Or(CharacterTypeTag).
						Or(VoidTypeTag).
						Or(MetaTypeTag).
						Or(PathTypeTag).
						Or(AddressTypeTag).
						Or(BlockTypeTag).
						Or(DeployedContractTypeTag).
						Or(CapabilityTypeTag).
						Or(FunctionTypeTag).
						Or(StorageCapabilityControllerTypeTag).
						Or(AccountCapabilityControllerTypeTag).
						Or(HashableStructTypeTag).
						Or(InclusiveRangeTypeTag)

	AnyResourceTypeTag = newTypeTagFromLowerMask(anyResourceTypeMask).
						Or(AnyResourceAttachmentTypeTag)

	AnyTypeTag = newTypeTagFromLowerMask(anyTypeMask).
				Or(AnyStructTypeTag).
				Or(AnyResourceTypeTag).
				Or(ConstantSizedTypeTag).
				Or(VariableSizedTypeTag).
				Or(DictionaryTypeTag).
				Or(GenericTypeTag).
				Or(InterfaceTypeTag).
				Or(TransactionTypeTag).
				Or(IntersectionTypeTag)
)
View Source 
var AccessCheckModes = []AccessCheckMode{
	AccessCheckModeStrict,
	AccessCheckModeNotSpecifiedRestricted,
	AccessCheckModeNotSpecifiedUnrestricted,
	AccessCheckModeNone,
}
View Source 
var AccountCapabilitiesType = &EntitlementType{
	Identifier: "AccountCapabilities",
}
View Source 
var AccountCapabilityControllerType = &SimpleType{
	Name:          AccountCapabilityControllerTypeName,
	QualifiedName: AccountCapabilityControllerTypeName,
	TypeID:        AccountCapabilityControllerTypeName,
	TypeTag:       AccountCapabilityControllerTypeTag,
	IsResource:    false,
	Storable:      false,
	Primitive:     false,
	Equatable:     false,
	Comparable:    false,
	Exportable:    false,
	Importable:    false,
	ContainFields: true,
}
View Source 
var AccountCapabilityControllerTypeAnnotation = NewTypeAnnotation(AccountCapabilityControllerType)
View Source 
var AccountCapabilityControllerTypeBorrowTypeFieldType = MetaType
View Source 
var AccountCapabilityControllerTypeCapabilityFieldType = &CapabilityType{}
View Source 
var AccountCapabilityControllerTypeCapabilityIDFieldType = UInt64Type
View Source 
var AccountCapabilityControllerTypeDeleteFunctionType = &FunctionType{
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var AccountCapabilityControllerTypeSetTagFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "tag",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var AccountCapabilityControllerTypeTagFieldType = StringType
View Source 
var AccountKeyType = func() *CompositeType {

	accountKeyType := &CompositeType{
		Identifier:        AccountKeyTypeName,
		Kind:              common.CompositeKindStructure,
		ImportableBuiltin: false,
	}

	const accountKeyKeyIndexFieldDocString = `The index of the account key`
	const accountKeyPublicKeyFieldDocString = `The public key of the account`
	const accountKeyHashAlgorithmFieldDocString = `The hash algorithm used by the public key`
	const accountKeyWeightFieldDocString = `The weight assigned to the public key`
	const accountKeyIsRevokedFieldDocString = `Flag indicating whether the key is revoked`

	var members = []*Member{
		NewUnmeteredPublicConstantFieldMember(
			accountKeyType,
			AccountKeyKeyIndexFieldName,
			IntType,
			accountKeyKeyIndexFieldDocString,
		),
		NewUnmeteredPublicConstantFieldMember(
			accountKeyType,
			AccountKeyPublicKeyFieldName,
			PublicKeyType,
			accountKeyPublicKeyFieldDocString,
		),
		NewUnmeteredPublicConstantFieldMember(
			accountKeyType,
			AccountKeyHashAlgoFieldName,
			HashAlgorithmType,
			accountKeyHashAlgorithmFieldDocString,
		),
		NewUnmeteredPublicConstantFieldMember(
			accountKeyType,
			AccountKeyWeightFieldName,
			UFix64Type,
			accountKeyWeightFieldDocString,
		),
		NewUnmeteredPublicConstantFieldMember(
			accountKeyType,
			AccountKeyIsRevokedFieldName,
			BoolType,
			accountKeyIsRevokedFieldDocString,
		),
	}

	accountKeyType.Members = MembersAsMap(members)
	accountKeyType.Fields = MembersFieldNames(members)
	return accountKeyType
}()

AccountKeyType represents the key associated with an account.

View Source 
var AccountKeyTypeAnnotation = NewTypeAnnotation(AccountKeyType)
View Source 
var AccountMappingType = &EntitlementMapType{
	Identifier:       "AccountMapping",
	IncludesIdentity: true,
	Relations: []EntitlementRelation{
		EntitlementRelation{
			Input:  StorageType,
			Output: SaveValueType,
		},
		EntitlementRelation{
			Input:  StorageType,
			Output: LoadValueType,
		},
		EntitlementRelation{
			Input:  StorageType,
			Output: CopyValueType,
		},
		EntitlementRelation{
			Input:  StorageType,
			Output: BorrowValueType,
		},
		EntitlementRelation{
			Input:  ContractsType,
			Output: AddContractType,
		},
		EntitlementRelation{
			Input:  ContractsType,
			Output: UpdateContractType,
		},
		EntitlementRelation{
			Input:  ContractsType,
			Output: RemoveContractType,
		},
		EntitlementRelation{
			Input:  KeysType,
			Output: AddKeyType,
		},
		EntitlementRelation{
			Input:  KeysType,
			Output: RevokeKeyType,
		},
		EntitlementRelation{
			Input:  InboxType,
			Output: PublishInboxCapabilityType,
		},
		EntitlementRelation{
			Input:  InboxType,
			Output: UnpublishInboxCapabilityType,
		},
		EntitlementRelation{
			Input:  InboxType,
			Output: ClaimInboxCapabilityType,
		},
		EntitlementRelation{
			Input:  CapabilitiesType,
			Output: StorageCapabilitiesType,
		},
		EntitlementRelation{
			Input:  CapabilitiesType,
			Output: AccountCapabilitiesType,
		},
	},
}
View Source 
var AccountReferenceType = &ReferenceType{
	Authorization: UnauthorizedAccess,
	Type:          AccountType,
}
View Source 
var AccountReferenceTypeAnnotation = NewTypeAnnotation(AccountReferenceType)
View Source 
var AccountType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         AccountTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	t.SetNestedType(Account_StorageTypeName, Account_StorageType)
	t.SetNestedType(Account_ContractsTypeName, Account_ContractsType)
	t.SetNestedType(Account_KeysTypeName, Account_KeysType)
	t.SetNestedType(Account_InboxTypeName, Account_InboxType)
	t.SetNestedType(Account_CapabilitiesTypeName, Account_CapabilitiesType)
	t.SetNestedType(Account_StorageCapabilitiesTypeName, Account_StorageCapabilitiesType)
	t.SetNestedType(Account_AccountCapabilitiesTypeName, Account_AccountCapabilitiesType)
	return t
}()
View Source 
var AccountTypeAddressFieldType = TheAddressType
View Source 
var AccountTypeAnnotation = NewTypeAnnotation(AccountType)
View Source 
var AccountTypeAvailableBalanceFieldType = UFix64Type
View Source 
var AccountTypeBalanceFieldType = UFix64Type
View Source 
var AccountTypeCapabilitiesFieldType = Account_CapabilitiesType
View Source 
var AccountTypeContractsFieldType = Account_ContractsType
View Source 
var AccountTypeInboxFieldType = Account_InboxType
View Source 
var AccountTypeKeysFieldType = Account_KeysType
View Source 
var AccountTypeStorageFieldType = Account_StorageType
View Source 
var Account_AccountCapabilitiesType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         Account_AccountCapabilitiesTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var Account_AccountCapabilitiesTypeForEachControllerFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "function",
			TypeAnnotation: NewTypeAnnotation(&FunctionType{
				Parameters: []Parameter{
					{
						TypeAnnotation: NewTypeAnnotation(&ReferenceType{
							Type:          AccountCapabilityControllerType,
							Authorization: UnauthorizedAccess,
						}),
					},
				},
				ReturnTypeAnnotation: NewTypeAnnotation(
					BoolType,
				),
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_AccountCapabilitiesTypeGetControllerFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Identifier:     "byCapabilityID",
			TypeAnnotation: NewTypeAnnotation(UInt64Type),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &ReferenceType{
				Type:          AccountCapabilityControllerType,
				Authorization: UnauthorizedAccess,
			},
		},
	),
}
View Source 
var Account_AccountCapabilitiesTypeGetControllersFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	ReturnTypeAnnotation: NewTypeAnnotation(
		&VariableSizedType{
			Type: &ReferenceType{
				Type:          AccountCapabilityControllerType,
				Authorization: UnauthorizedAccess,
			},
		},
	),
}
View Source 
var Account_AccountCapabilitiesTypeIssueFunctionType = &FunctionType{
	TypeParameters: []*TypeParameter{
		Account_AccountCapabilitiesTypeIssueFunctionTypeParameterT,
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		MustInstantiate(
			&CapabilityType{},
			&GenericType{
				TypeParameter: Account_AccountCapabilitiesTypeIssueFunctionTypeParameterT,
			},
		),
	),
}
View Source 
var Account_AccountCapabilitiesTypeIssueFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AccountType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_AccountCapabilitiesTypeIssueWithTypeFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "type",
			TypeAnnotation: NewTypeAnnotation(MetaType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&CapabilityType{},
	),
}
View Source 
var Account_CapabilitiesType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         Account_CapabilitiesTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var Account_CapabilitiesTypeAccountFieldType = Account_AccountCapabilitiesType
View Source 
var Account_CapabilitiesTypeBorrowFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	TypeParameters: []*TypeParameter{
		Account_CapabilitiesTypeBorrowFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "path",
			TypeAnnotation: NewTypeAnnotation(PublicPathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &GenericType{
				TypeParameter: Account_CapabilitiesTypeBorrowFunctionTypeParameterT,
			},
		},
	),
}
View Source 
var Account_CapabilitiesTypeBorrowFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AnyType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_CapabilitiesTypeExistsFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "path",
			TypeAnnotation: NewTypeAnnotation(PublicPathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		BoolType,
	),
}
View Source 
var Account_CapabilitiesTypeGetFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	TypeParameters: []*TypeParameter{
		Account_CapabilitiesTypeGetFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "path",
			TypeAnnotation: NewTypeAnnotation(PublicPathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		MustInstantiate(
			&CapabilityType{},
			&GenericType{
				TypeParameter: Account_CapabilitiesTypeGetFunctionTypeParameterT,
			},
		),
	),
}
View Source 
var Account_CapabilitiesTypeGetFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AnyType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_CapabilitiesTypePublishFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "capability",
			TypeAnnotation: NewTypeAnnotation(&CapabilityType{}),
		},
		{
			Identifier:     "at",
			TypeAnnotation: NewTypeAnnotation(PublicPathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_CapabilitiesTypeStorageFieldType = Account_StorageCapabilitiesType
View Source 
var Account_CapabilitiesTypeUnpublishFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "path",
			TypeAnnotation: NewTypeAnnotation(PublicPathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &CapabilityType{},
		},
	),
}
View Source 
var Account_ContractsType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         Account_ContractsTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var Account_ContractsTypeAddFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
		{
			Identifier: "code",
			TypeAnnotation: NewTypeAnnotation(&VariableSizedType{
				Type: UInt8Type,
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		DeployedContractType,
	),
}
View Source 
var Account_ContractsTypeBorrowFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	TypeParameters: []*TypeParameter{
		Account_ContractsTypeBorrowFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &GenericType{
				TypeParameter: Account_ContractsTypeBorrowFunctionTypeParameterT,
			},
		},
	),
}
View Source 
var Account_ContractsTypeBorrowFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AnyType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_ContractsTypeGetFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: DeployedContractType,
		},
	),
}
View Source 
var Account_ContractsTypeNamesFieldType = &VariableSizedType{
	Type: StringType,
}
View Source 
var Account_ContractsTypeRemoveFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: DeployedContractType,
		},
	),
}
View Source 
var Account_ContractsTypeTryUpdateFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
		{
			Identifier: "code",
			TypeAnnotation: NewTypeAnnotation(&VariableSizedType{
				Type: UInt8Type,
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		DeploymentResultType,
	),
}
View Source 
var Account_ContractsTypeUpdateFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
		{
			Identifier: "code",
			TypeAnnotation: NewTypeAnnotation(&VariableSizedType{
				Type: UInt8Type,
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		DeployedContractType,
	),
}
View Source 
var Account_InboxType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         Account_InboxTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var Account_InboxTypeClaimFunctionType = &FunctionType{
	TypeParameters: []*TypeParameter{
		Account_InboxTypeClaimFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
		{
			Identifier:     "provider",
			TypeAnnotation: NewTypeAnnotation(TheAddressType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: MustInstantiate(
				&CapabilityType{},
				&GenericType{
					TypeParameter: Account_InboxTypeClaimFunctionTypeParameterT,
				},
			),
		},
	),
}
View Source 
var Account_InboxTypeClaimFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AnyType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_InboxTypePublishFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "value",
			TypeAnnotation: NewTypeAnnotation(&CapabilityType{}),
		},
		{
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
		{
			Identifier:     "recipient",
			TypeAnnotation: NewTypeAnnotation(TheAddressType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_InboxTypeUnpublishFunctionType = &FunctionType{
	TypeParameters: []*TypeParameter{
		Account_InboxTypeUnpublishFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "name",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: MustInstantiate(
				&CapabilityType{},
				&GenericType{
					TypeParameter: Account_InboxTypeUnpublishFunctionTypeParameterT,
				},
			),
		},
	),
}
View Source 
var Account_InboxTypeUnpublishFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AnyType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_KeysType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         Account_KeysTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var Account_KeysTypeAddFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Identifier:     "publicKey",
			TypeAnnotation: NewTypeAnnotation(PublicKeyType),
		},
		{
			Identifier:     "hashAlgorithm",
			TypeAnnotation: NewTypeAnnotation(HashAlgorithmType),
		},
		{
			Identifier:     "weight",
			TypeAnnotation: NewTypeAnnotation(UFix64Type),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		AccountKeyType,
	),
}
View Source 
var Account_KeysTypeCountFieldType = UInt64Type
View Source 
var Account_KeysTypeForEachFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "function",
			TypeAnnotation: NewTypeAnnotation(&FunctionType{
				Parameters: []Parameter{
					{
						TypeAnnotation: NewTypeAnnotation(AccountKeyType),
					},
				},
				ReturnTypeAnnotation: NewTypeAnnotation(
					BoolType,
				),
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_KeysTypeGetFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Identifier:     "keyIndex",
			TypeAnnotation: NewTypeAnnotation(IntType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: AccountKeyType,
		},
	),
}
View Source 
var Account_KeysTypeRevokeFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Identifier:     "keyIndex",
			TypeAnnotation: NewTypeAnnotation(IntType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: AccountKeyType,
		},
	),
}
View Source 
var Account_StorageCapabilitiesType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         Account_StorageCapabilitiesTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var Account_StorageCapabilitiesTypeForEachControllerFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Identifier:     "forPath",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "function",
			TypeAnnotation: NewTypeAnnotation(&FunctionType{
				Parameters: []Parameter{
					{
						TypeAnnotation: NewTypeAnnotation(&ReferenceType{
							Type:          StorageCapabilityControllerType,
							Authorization: UnauthorizedAccess,
						}),
					},
				},
				ReturnTypeAnnotation: NewTypeAnnotation(
					BoolType,
				),
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_StorageCapabilitiesTypeGetControllerFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Identifier:     "byCapabilityID",
			TypeAnnotation: NewTypeAnnotation(UInt64Type),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &ReferenceType{
				Type:          StorageCapabilityControllerType,
				Authorization: UnauthorizedAccess,
			},
		},
	),
}
View Source 
var Account_StorageCapabilitiesTypeGetControllersFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Identifier:     "forPath",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&VariableSizedType{
			Type: &ReferenceType{
				Type:          StorageCapabilityControllerType,
				Authorization: UnauthorizedAccess,
			},
		},
	),
}
View Source 
var Account_StorageCapabilitiesTypeIssueFunctionType = &FunctionType{
	TypeParameters: []*TypeParameter{
		Account_StorageCapabilitiesTypeIssueFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "path",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		MustInstantiate(
			&CapabilityType{},
			&GenericType{
				TypeParameter: Account_StorageCapabilitiesTypeIssueFunctionTypeParameterT,
			},
		),
	),
}
View Source 
var Account_StorageCapabilitiesTypeIssueFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AnyType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_StorageCapabilitiesTypeIssueWithTypeFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "path",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
		{
			Identifier:     "type",
			TypeAnnotation: NewTypeAnnotation(MetaType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&CapabilityType{},
	),
}
View Source 
var Account_StorageType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         Account_StorageTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var Account_StorageTypeBorrowFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	TypeParameters: []*TypeParameter{
		Account_StorageTypeBorrowFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Identifier:     "from",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &GenericType{
				TypeParameter: Account_StorageTypeBorrowFunctionTypeParameterT,
			},
		},
	),
}
View Source 
var Account_StorageTypeBorrowFunctionTypeParameterT = &TypeParameter{
	Name: "T",
	TypeBound: &ReferenceType{
		Type:          AnyType,
		Authorization: UnauthorizedAccess,
	},
}
View Source 
var Account_StorageTypeCapacityFieldType = UInt64Type
View Source 
var Account_StorageTypeCheckFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	TypeParameters: []*TypeParameter{
		Account_StorageTypeCheckFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Identifier:     "from",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		BoolType,
	),
}
View Source 
var Account_StorageTypeCheckFunctionTypeParameterT = &TypeParameter{
	Name:      "T",
	TypeBound: AnyType,
}
View Source 
var Account_StorageTypeCopyFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	TypeParameters: []*TypeParameter{
		Account_StorageTypeCopyFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Identifier:     "from",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &GenericType{
				TypeParameter: Account_StorageTypeCopyFunctionTypeParameterT,
			},
		},
	),
}
View Source 
var Account_StorageTypeCopyFunctionTypeParameterT = &TypeParameter{
	Name:      "T",
	TypeBound: AnyStructType,
}
View Source 
var Account_StorageTypeForEachPublicFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "function",
			TypeAnnotation: NewTypeAnnotation(&FunctionType{
				Parameters: []Parameter{
					{
						TypeAnnotation: NewTypeAnnotation(PublicPathType),
					},
					{
						TypeAnnotation: NewTypeAnnotation(MetaType),
					},
				},
				ReturnTypeAnnotation: NewTypeAnnotation(
					BoolType,
				),
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_StorageTypeForEachStoredFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "function",
			TypeAnnotation: NewTypeAnnotation(&FunctionType{
				Parameters: []Parameter{
					{
						TypeAnnotation: NewTypeAnnotation(StoragePathType),
					},
					{
						TypeAnnotation: NewTypeAnnotation(MetaType),
					},
				},
				ReturnTypeAnnotation: NewTypeAnnotation(
					BoolType,
				),
			}),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_StorageTypeLoadFunctionType = &FunctionType{
	TypeParameters: []*TypeParameter{
		Account_StorageTypeLoadFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Identifier:     "from",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: &GenericType{
				TypeParameter: Account_StorageTypeLoadFunctionTypeParameterT,
			},
		},
	),
}
View Source 
var Account_StorageTypeLoadFunctionTypeParameterT = &TypeParameter{
	Name:      "T",
	TypeBound: StorableType,
}
View Source 
var Account_StorageTypePublicPathsFieldType = &VariableSizedType{
	Type: PublicPathType,
}
View Source 
var Account_StorageTypeSaveFunctionType = &FunctionType{
	TypeParameters: []*TypeParameter{
		Account_StorageTypeSaveFunctionTypeParameterT,
	},
	Parameters: []Parameter{
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "value",
			TypeAnnotation: NewTypeAnnotation(&GenericType{
				TypeParameter: Account_StorageTypeSaveFunctionTypeParameterT,
			}),
		},
		{
			Identifier:     "to",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var Account_StorageTypeSaveFunctionTypeParameterT = &TypeParameter{
	Name:      "T",
	TypeBound: StorableType,
}
View Source 
var Account_StorageTypeStoragePathsFieldType = &VariableSizedType{
	Type: StoragePathType,
}
View Source 
var Account_StorageTypeTypeFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Label:          "at",
			Identifier:     "path",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		&OptionalType{
			Type: MetaType,
		},
	),
}
View Source 
var Account_StorageTypeUsedFieldType = UInt64Type
View Source 
var AddContractType = &EntitlementType{
	Identifier: "AddContract",
}
View Source 
var AddKeyType = &EntitlementType{
	Identifier: "AddKey",
}
View Source 
var AddressConversionFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "value",
			TypeAnnotation: IntegerTypeAnnotation,
		},
	},
	ReturnTypeAnnotation: AddressTypeAnnotation,
	ArgumentExpressionsCheck: func(checker *Checker, argumentExpressions []ast.Expression, _ ast.HasPosition) {
		if len(argumentExpressions) < 1 {
			return
		}

		intExpression, ok := argumentExpressions[0].(*ast.IntegerExpression)
		if !ok {
			return
		}

		CheckAddressLiteral(nil, intExpression, checker.report)
	},
}
View Source 
var AddressTypeAnnotation = NewTypeAnnotation(TheAddressType)
View Source 
var AddressTypeFromBytesFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "bytes",
			TypeAnnotation: NewTypeAnnotation(ByteArrayType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(TheAddressType),
}
View Source 
var AddressTypeFromStringFunctionType = FromStringFunctionType(TheAddressType)
View Source 
var AddressTypeMaxIntBig = new(big.Int).SetUint64(math.MaxUint64)
View Source 
var AddressTypeMinIntBig = new(big.Int)
View Source 
var AddressTypeToBytesFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	nil,
	ByteArrayTypeAnnotation,
)
View Source 
var AllFixedPointTypes = common.Concat(
	AllUnsignedFixedPointTypes,
	AllSignedFixedPointTypes,
	[]Type{
		FixedPointType,
		SignedFixedPointType,
	},
)
View Source 
var AllFixedSizeUnsignedIntegerTypes = []Type{

	UInt8Type,
	UInt16Type,
	UInt32Type,
	UInt64Type,
	UInt128Type,
	UInt256Type,

	Word8Type,
	Word16Type,
	Word32Type,
	Word64Type,
	Word128Type,
	Word256Type,
}
View Source 
var AllIntegerTypes = common.Concat(
	AllUnsignedIntegerTypes,
	AllSignedIntegerTypes,
	AllNonLeafIntegerTypes,
)
View Source 
var AllNonLeafIntegerTypes = []Type{
	IntegerType,
	SignedIntegerType,
	FixedSizeUnsignedIntegerType,
}
View Source 
var AllNumberTypes = common.Concat(
	AllIntegerTypes,
	AllFixedPointTypes,
	[]Type{
		NumberType,
		SignedNumberType,
	},
)
View Source 
var AllSignedFixedPointTypes = []Type{
	Fix64Type,
}
View Source 
var AllSignedIntegerTypes = []Type{
	IntType,
	Int8Type,
	Int16Type,
	Int32Type,
	Int64Type,
	Int128Type,
	Int256Type,
}
View Source 
var AllUnsignedFixedPointTypes = []Type{
	UFix64Type,
}
View Source 
var AllUnsignedIntegerTypes = common.Concat(
	AllFixedSizeUnsignedIntegerTypes,
	[]Type{
		UIntType,
	},
)
View Source 
var AnyResourceAttachmentType = &SimpleType{
	Name:          AnyResourceAttachmentTypeName,
	QualifiedName: AnyResourceAttachmentTypeName,
	TypeID:        AnyResourceAttachmentTypeName,
	TypeTag:       AnyResourceAttachmentTypeTag,
	IsResource:    true,
	Primitive:     false,

	Storable:   true,
	Equatable:  false,
	Comparable: false,

	Exportable: true,
	Importable: false,
}

AnyResourceAttachmentType represents the top type of all resource attachment types

View Source 
var AnyResourceType = &SimpleType{
	Name:          "AnyResource",
	QualifiedName: "AnyResource",
	TypeID:        "AnyResource",
	TypeTag:       AnyResourceTypeTag,
	IsResource:    true,
	Primitive:     false,

	Storable:   true,
	Equatable:  false,
	Comparable: false,

	Exportable:    true,
	Importable:    false,
	ContainFields: true,
}

AnyResourceType represents the top type of all resource types

View Source 
var AnyStructAttachmentType = &SimpleType{
	Name:          AnyStructAttachmentTypeName,
	QualifiedName: AnyStructAttachmentTypeName,
	TypeID:        AnyStructAttachmentTypeName,
	TypeTag:       AnyStructAttachmentTypeTag,
	IsResource:    false,
	Primitive:     false,

	Storable:   true,
	Equatable:  false,
	Comparable: false,

	Exportable: true,
	Importable: false,
}

AnyStructAttachmentType represents the top type of all struct attachment types

View Source 
var AnyStructType = &SimpleType{
	Name:          "AnyStruct",
	QualifiedName: "AnyStruct",
	TypeID:        "AnyStruct",
	TypeTag:       AnyStructTypeTag,
	IsResource:    false,

	Storable:   true,
	Primitive:  false,
	Equatable:  false,
	Comparable: false,
	Exportable: true,

	Importable:    true,
	ContainFields: true,
}

AnyStructType represents the top type of all non-resource types

View Source 
var AnyStructTypeAnnotation = NewTypeAnnotation(AnyStructType)
View Source 
var AnyType = &SimpleType{
	Name:          "Any",
	QualifiedName: "Any",
	TypeID:        "Any",
	TypeTag:       AnyTypeTag,
	IsResource:    false,

	Storable:   true,
	Primitive:  false,
	Equatable:  false,
	Comparable: false,

	Exportable: false,
	Importable: false,
}

AnyType represents the top type of all types. NOTE: This type is only used internally and is not available in programs.

View Source 
var BaseTypeActivation = NewVariableActivation(nil)

BaseTypeActivation is the base activation that contains the types available in programs

View Source 
var BaseValueActivation = NewVariableActivation(nil)

BaseValueActivation is the base activation that contains the values available in programs

View Source 
var BlockType = &SimpleType{
	Name:          BlockTypeName,
	QualifiedName: BlockTypeName,
	TypeID:        BlockTypeName,
	TypeTag:       BlockTypeTag,
	IsResource:    false,
	Storable:      false,
	Primitive:     false,
	Equatable:     false,
	Comparable:    false,
	Exportable:    false,
	Importable:    false,
	ContainFields: true,
}
View Source 
var BlockTypeAnnotation = NewTypeAnnotation(BlockType)
View Source 
var BlockTypeHeightFieldType = UInt64Type
View Source 
var BlockTypeIdFieldType = &ConstantSizedType{
	Type: UInt8Type,
	Size: 32,
}
View Source 
var BlockTypeTimestampFieldType = UFix64Type
View Source 
var BlockTypeViewFieldType = UInt64Type
View Source 
var BoolType = &SimpleType{
	Name:          "Bool",
	QualifiedName: "Bool",
	TypeID:        "Bool",
	TypeTag:       BoolTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    true,
	Exportable:    true,
	Importable:    true,
	conformances: []*InterfaceType{
		StructStringerType,
	},
}

BoolType represents the boolean type

View Source 
var BoolTypeAnnotation = NewTypeAnnotation(BoolType)
View Source 
var BorrowValueType = &EntitlementType{
	Identifier: "BorrowValue",
}
View Source 
var BuiltinEntitlementMappings = map[string]*EntitlementMapType{
	IdentityType.QualifiedIdentifier(): IdentityType,
}
View Source 
var BuiltinEntitlements = map[string]*EntitlementType{}
View Source 
var ByteArrayArrayType = &VariableSizedType{
	Type: ByteArrayType,
}

ByteArrayArrayType represents the type [[UInt8]]

View Source 
var ByteArrayArrayTypeAnnotation = NewTypeAnnotation(ByteArrayArrayType)
View Source 
var ByteArrayType = &VariableSizedType{
	Type: UInt8Type,
}

ByteArrayType represents the type [UInt8]

View Source 
var ByteArrayTypeAnnotation = NewTypeAnnotation(ByteArrayType)
View Source 
var CapabilitiesMappingType = &EntitlementMapType{
	Identifier:       "CapabilitiesMapping",
	IncludesIdentity: true,
	Relations: []EntitlementRelation{
		EntitlementRelation{
			Input:  StorageCapabilitiesType,
			Output: GetStorageCapabilityControllerType,
		},
		EntitlementRelation{
			Input:  StorageCapabilitiesType,
			Output: IssueStorageCapabilityControllerType,
		},
		EntitlementRelation{
			Input:  AccountCapabilitiesType,
			Output: GetAccountCapabilityControllerType,
		},
		EntitlementRelation{
			Input:  AccountCapabilitiesType,
			Output: IssueAccountCapabilityControllerType,
		},
	},
}
View Source 
var CapabilitiesType = &EntitlementType{
	Identifier: "Capabilities",
}
View Source 
var CapabilityPathType = &SimpleType{
	Name:          "CapabilityPath",
	QualifiedName: "CapabilityPath",
	TypeID:        "CapabilityPath",
	TypeTag:       CapabilityPathTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    false,
	Exportable:    true,
	Importable:    true,
	conformances: []*InterfaceType{
		StructStringerType,
	},
}

CapabilityPathType

View Source 
var CapabilityPathTypeAnnotation = NewTypeAnnotation(CapabilityPathType)
View Source 
var CapabilityTypeAddressFieldType = TheAddressType
View Source 
var CapabilityTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "type",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	OptionalMetaTypeAnnotation,
)
View Source 
var CapabilityTypeIDFieldType = UInt64Type
View Source 
var CharacterType = &SimpleType{
	Name:          CharacterTypeName,
	QualifiedName: CharacterTypeName,
	TypeID:        CharacterTypeName,
	TypeTag:       CharacterTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    true,
	Exportable:    true,
	Importable:    true,
	ContainFields: false,
	conformances:  []*InterfaceType{StructStringerType},
}
View Source 
var CharacterTypeToStringFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	ReturnTypeAnnotation: NewTypeAnnotation(
		StringType,
	),
}
View Source 
var CharacterTypeUtf8FieldType = &VariableSizedType{
	Type: UInt8Type,
}
View Source 
var ClaimInboxCapabilityType = &EntitlementType{
	Identifier: "ClaimInboxCapability",
}
View Source 
var CompositeTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "identifier",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	OptionalMetaTypeAnnotation,
)
View Source 
var ConstantSizedArrayTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier:     "type",
			TypeAnnotation: MetaTypeAnnotation,
		},
		{
			Identifier:     "size",
			TypeAnnotation: IntTypeAnnotation,
		},
	},
	MetaTypeAnnotation,
)
View Source 
var ContractAccountFieldType = &ReferenceType{
	Type:          AccountType,
	Authorization: FullyEntitledAccountAccess,
}
View Source 
var ContractsType = &EntitlementType{
	Identifier: "Contracts",
}
View Source 
var CopyValueType = &EntitlementType{
	Identifier: "CopyValue",
}
View Source 
var DeployedContractType = &SimpleType{
	Name:          DeployedContractTypeName,
	QualifiedName: DeployedContractTypeName,
	TypeID:        DeployedContractTypeName,
	TypeTag:       DeployedContractTypeTag,
	IsResource:    false,
	Storable:      false,
	Primitive:     false,
	Equatable:     false,
	Comparable:    false,
	Exportable:    false,
	Importable:    false,
	ContainFields: true,
}
View Source 
var DeployedContractTypeAddressFieldType = TheAddressType
View Source 
var DeployedContractTypeCodeFieldType = &VariableSizedType{
	Type: UInt8Type,
}
View Source 
var DeployedContractTypeNameFieldType = StringType
View Source 
var DeployedContractTypePublicTypesFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	ReturnTypeAnnotation: NewTypeAnnotation(
		&VariableSizedType{
			Type: MetaType,
		},
	),
}
View Source 
var DeploymentResultType = func() *CompositeType {
	var t = &CompositeType{
		Identifier:         DeploymentResultTypeName,
		Kind:               common.CompositeKindStructure,
		ImportableBuiltin:  false,
		HasComputedMembers: true,
	}

	return t
}()
View Source 
var DeploymentResultTypeDeployedContractFieldType = &OptionalType{
	Type: DeployedContractType,
}
View Source 
var DictionaryTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier:     "key",
			TypeAnnotation: MetaTypeAnnotation,
		},
		{
			Identifier:     "value",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	OptionalMetaTypeAnnotation,
)
View Source 
var FullyEntitledAccountAccess = NewEntitlementSetAccess(
	[]*EntitlementType{
		StorageType,
		ContractsType,
		KeysType,
		InboxType,
		CapabilitiesType,
	},
	Conjunction,
)

FullyEntitledAccountAccess represents 

auth(Storage, Contracts, Keys, Inbox, Capabilities)
View Source 
var FullyEntitledAccountReferenceType = &ReferenceType{
	Authorization: FullyEntitledAccountAccess,
	Type:          AccountType,
}

FullyEntitledAccountReferenceType represents the type 

auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account
View Source 
var FullyEntitledAccountReferenceTypeAnnotation = NewTypeAnnotation(FullyEntitledAccountReferenceType)
View Source 
var FunctionTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier: "parameters",
			TypeAnnotation: NewTypeAnnotation(
				&VariableSizedType{
					Type: MetaType,
				},
			),
		},
		{
			Identifier:     "return",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	MetaTypeAnnotation,
)
View Source 
var GetAccountCapabilityControllerType = &EntitlementType{
	Identifier: "GetAccountCapabilityController",
}
View Source 
var GetStorageCapabilityControllerType = &EntitlementType{
	Identifier: "GetStorageCapabilityController",
}
View Source 
var GetTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	nil,
	MetaTypeAnnotation,
)
View Source 
var HashAlgorithmType = newNativeEnumType(
	HashAlgorithmTypeName,
	UInt8Type,
	func(enumType *CompositeType) []*Member {
		return []*Member{
			NewUnmeteredPublicFunctionMember(
				enumType,
				HashAlgorithmTypeHashFunctionName,
				HashAlgorithmTypeHashFunctionType,
				HashAlgorithmTypeHashFunctionDocString,
			),
			NewUnmeteredPublicFunctionMember(
				enumType,
				HashAlgorithmTypeHashWithTagFunctionName,
				HashAlgorithmTypeHashWithTagFunctionType,
				HashAlgorithmTypeHashWithTagFunctionDocString,
			),
		}
	},
)
View Source 
var HashAlgorithmTypeAnnotation = NewTypeAnnotation(HashAlgorithmType)
View Source 
var HashAlgorithmTypeHashFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "data",
			TypeAnnotation: ByteArrayTypeAnnotation,
		},
	},
	ByteArrayTypeAnnotation,
)
View Source 
var HashAlgorithmTypeHashWithTagFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "data",
			TypeAnnotation: ByteArrayTypeAnnotation,
		},
		{
			Identifier:     "tag",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	ByteArrayTypeAnnotation,
)
View Source 
var HashAlgorithms = []HashAlgorithm{
	HashAlgorithmSHA2_256,
	HashAlgorithmSHA2_384,
	HashAlgorithmSHA3_256,
	HashAlgorithmSHA3_384,
	HashAlgorithmKMAC128_BLS_BLS12_381,
	HashAlgorithmKECCAK_256,
}
View Source 
var HashableStructType = &SimpleType{
	Name:          HashableStructTypeName,
	QualifiedName: HashableStructTypeName,
	TypeID:        HashableStructTypeName,
	TypeTag:       HashableStructTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     false,
	Equatable:     false,
	Comparable:    false,
	Exportable:    true,
	Importable:    true,
	ContainFields: false,
}
View Source 
var IdentityType = func() *EntitlementMapType {
	m := NewEntitlementMapType(nil, nil, IdentityMappingIdentifier)
	m.IncludesIdentity = true
	m.resolveInclusions.Do(func() {})
	return m
}()

IdentityType represents the `Identity` entitlement mapping type. It is an empty map that includes the Identity map, and is considered already "resolved" with regards to its (vacuously empty) inclusions. defining it this way eliminates the need to do any special casing for its behavior

View Source 
var InboxType = &EntitlementType{
	Identifier: "Inbox",
}
View Source 
var InclusiveRangeTypeFieldNames = []string{
	InclusiveRangeTypeStartFieldName,
	InclusiveRangeTypeEndFieldName,
	InclusiveRangeTypeStepFieldName,
}
View Source 
var InclusiveRangeTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "type",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	OptionalMetaTypeAnnotation,
)
View Source 
var InsertType = &EntitlementType{
	Identifier: "Insert",
}
View Source 
var IntersectionTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier: "types",
			TypeAnnotation: NewTypeAnnotation(
				&VariableSizedType{
					Type: StringType,
				},
			),
		},
	},
	OptionalMetaTypeAnnotation,
)
View Source 
var InvalidType = &SimpleType{
	Name:          "<<invalid>>",
	QualifiedName: "<<invalid>>",
	TypeID:        "<<invalid>>",
	TypeTag:       InvalidTypeTag,
	IsResource:    false,
	Storable:      false,
	Primitive:     false,
	Equatable:     false,
	Comparable:    false,
	Exportable:    false,
	Importable:    false,
}

InvalidType represents a type that is invalid. It is the result of type checking failing and can't be expressed in programs.

View Source 
var IsInstanceFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "type",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	BoolTypeAnnotation,
)
View Source 
var IssueAccountCapabilityControllerType = &EntitlementType{
	Identifier: "IssueAccountCapabilityController",
}
View Source 
var IssueStorageCapabilityControllerType = &EntitlementType{
	Identifier: "IssueStorageCapabilityController",
}
View Source 
var KeysType = &EntitlementType{
	Identifier: "Keys",
}
View Source 
var LoadValueType = &EntitlementType{
	Identifier: "LoadValue",
}
View Source 
var MetaType = &SimpleType{
	Name:          MetaTypeName,
	QualifiedName: MetaTypeName,
	TypeID:        MetaTypeName,
	TypeTag:       MetaTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     false,
	Equatable:     true,
	Comparable:    false,
	Exportable:    true,
	Importable:    true,
}

MetaType represents the type of a type.

View Source 
var MetaTypeAddressFieldType = &OptionalType{
	Type: TheAddressType,
}
View Source 
var MetaTypeAnnotation = NewTypeAnnotation(MetaType)
View Source 
var MetaTypeContractNameFieldType = &OptionalType{
	Type: StringType,
}
View Source 
var MetaTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	nil,
	MetaTypeAnnotation,
)
View Source 
var MetaTypeIsRecoveredFieldType = BoolType
View Source 
var MetaTypeIsSubtypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          "of",
			Identifier:     "otherType",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	BoolTypeAnnotation,
)
View Source 
var MutateType = &EntitlementType{
	Identifier: "Mutate",
}
View Source 
var NativeCompositeTypes = map[string]*CompositeType{}
View Source 
var NativeInterfaceTypes = map[string]*InterfaceType{}
View Source 
var NeverType = &SimpleType{
	Name:          "Never",
	QualifiedName: "Never",
	TypeID:        "Never",
	TypeTag:       NeverTypeTag,
	IsResource:    false,
	Storable:      false,
	Primitive:     false,
	Equatable:     false,
	Comparable:    false,
	Exportable:    false,
	Importable:    false,
}

NeverType represents the bottom type

View Source 
var NeverTypeAnnotation = NewTypeAnnotation(NeverType)
View Source 
var NilType = &OptionalType{
	Type: NeverType,
}
View Source 
var OptionalMetaTypeAnnotation = NewTypeAnnotation(&OptionalType{
	Type: MetaType,
})
View Source 
var OptionalTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "type",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	MetaTypeAnnotation,
)
View Source 
var PathType = &SimpleType{
	Name:          "Path",
	QualifiedName: "Path",
	TypeID:        "Path",
	TypeTag:       PathTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    false,
	Exportable:    true,
	Importable:    true,
	conformances: []*InterfaceType{
		StructStringerType,
	},
}

PathType

View Source 
var PathTypeAnnotation = NewTypeAnnotation(PathType)
View Source 
var PrivatePathConversionFunctionType = pathConversionFunctionType(PrivatePathType)
View Source 
var PrivatePathType = &SimpleType{
	Name:          "PrivatePath",
	QualifiedName: "PrivatePath",
	TypeID:        "PrivatePath",
	TypeTag:       PrivatePathTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    false,
	Exportable:    true,
	Importable:    true,
	conformances: []*InterfaceType{
		StructStringerType,
	},
}

PrivatePathType

View Source 
var PrivatePathTypeAnnotation = NewTypeAnnotation(PrivatePathType)
View Source 
var PublicKeyArrayType = &VariableSizedType{
	Type: PublicKeyType,
}
View Source 
var PublicKeyArrayTypeAnnotation = NewTypeAnnotation(PublicKeyArrayType)
View Source 
var PublicKeyType = func() *CompositeType {

	publicKeyType := &CompositeType{
		Identifier:         PublicKeyTypeName,
		Kind:               common.CompositeKindStructure,
		HasComputedMembers: true,
		ImportableBuiltin:  true,
	}

	var members = []*Member{
		NewUnmeteredPublicConstantFieldMember(
			publicKeyType,
			PublicKeyTypePublicKeyFieldName,
			ByteArrayType,
			publicKeyKeyFieldDocString,
		),
		NewUnmeteredPublicConstantFieldMember(
			publicKeyType,
			PublicKeyTypeSignAlgoFieldName,
			SignatureAlgorithmType,
			publicKeySignAlgoFieldDocString,
		),
		NewUnmeteredPublicFunctionMember(
			publicKeyType,
			PublicKeyTypeVerifyFunctionName,
			PublicKeyVerifyFunctionType,
			publicKeyVerifyFunctionDocString,
		),
		NewUnmeteredPublicFunctionMember(
			publicKeyType,
			PublicKeyTypeVerifyPoPFunctionName,
			PublicKeyVerifyPoPFunctionType,
			publicKeyVerifyPoPFunctionDocString,
		),
	}

	publicKeyType.Members = MembersAsMap(members)
	publicKeyType.Fields = MembersFieldNames(members)

	return publicKeyType
}()

PublicKeyType represents the public key associated with an account key.

View Source 
var PublicKeyTypeAnnotation = NewTypeAnnotation(PublicKeyType)
View Source 
var PublicKeyVerifyFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier:     "signature",
			TypeAnnotation: ByteArrayTypeAnnotation,
		},
		{
			Identifier:     "signedData",
			TypeAnnotation: ByteArrayTypeAnnotation,
		},
		{
			Identifier:     "domainSeparationTag",
			TypeAnnotation: StringTypeAnnotation,
		},
		{
			Identifier:     "hashAlgorithm",
			TypeAnnotation: HashAlgorithmTypeAnnotation,
		},
	},
	BoolTypeAnnotation,
)
View Source 
var PublicKeyVerifyPoPFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "proof",
			TypeAnnotation: ByteArrayTypeAnnotation,
		},
	},
	BoolTypeAnnotation,
)
View Source 
var PublicPathConversionFunctionType = pathConversionFunctionType(PublicPathType)
View Source 
var PublicPathType = &SimpleType{
	Name:          "PublicPath",
	QualifiedName: "PublicPath",
	TypeID:        "PublicPath",
	TypeTag:       PublicPathTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    false,
	Exportable:    true,
	Importable:    true,
	conformances: []*InterfaceType{
		StructStringerType,
	},
}

PublicPathType

View Source 
var PublicPathTypeAnnotation = NewTypeAnnotation(PublicPathType)
View Source 
var PublishCapabilityType = &EntitlementType{
	Identifier: "PublishCapability",
}
View Source 
var PublishInboxCapabilityType = &EntitlementType{
	Identifier: "PublishInboxCapability",
}
View Source 
var ReferenceTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier: "entitlements",
			TypeAnnotation: NewTypeAnnotation(
				&VariableSizedType{
					Type: StringType,
				},
			),
		},
		{
			Identifier:     "type",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	OptionalMetaTypeAnnotation,
)
View Source 
var RemoveContractType = &EntitlementType{
	Identifier: "RemoveContract",
}
View Source 
var RemoveType = &EntitlementType{
	Identifier: "Remove",
}
View Source 
var ResourceOwnerFieldType = &OptionalType{
	Type: AccountReferenceType,
}
View Source 
var ResourceUUIDFieldType = UInt64Type
View Source 
var RevokeKeyType = &EntitlementType{
	Identifier: "RevokeKey",
}
View Source 
var SaturatingArithmeticTypeFunctionTypes = map[Type]*FunctionType{}
View Source 
var SaveValueType = &EntitlementType{
	Identifier: "SaveValue",
}
View Source 
var SignatureAlgorithmType = newNativeEnumType(
	SignatureAlgorithmTypeName,
	UInt8Type,
	nil,
)
View Source 
var SignatureAlgorithmTypeAnnotation = NewTypeAnnotation(SignatureAlgorithmType)
View Source 
var SignatureAlgorithms = []SignatureAlgorithm{
	SignatureAlgorithmECDSA_P256,
	SignatureAlgorithmECDSA_secp256k1,
	SignatureAlgorithmBLS_BLS12_381,
}
View Source 
var StorableType = &SimpleType{
	Name:          "Storable",
	QualifiedName: "Storable",
	TypeID:        "Storable",

	IsResource: false,
	Storable:   true,
	Primitive:  false,
	Equatable:  false,
	Comparable: false,
	Exportable: false,
	Importable: false,
}

StorableType is the supertype of all types which are storable.

It is only used as e.g. a type bound, but is not accessible to user programs, i.e. can't be used in type annotations for e.g. parameters, return types, fields, etc.

View Source 
var StorageCapabilitiesType = &EntitlementType{
	Identifier: "StorageCapabilities",
}
View Source 
var StorageCapabilityControllerType = &SimpleType{
	Name:          StorageCapabilityControllerTypeName,
	QualifiedName: StorageCapabilityControllerTypeName,
	TypeID:        StorageCapabilityControllerTypeName,
	TypeTag:       StorageCapabilityControllerTypeTag,
	IsResource:    false,
	Storable:      false,
	Primitive:     false,
	Equatable:     false,
	Comparable:    false,
	Exportable:    false,
	Importable:    false,
	ContainFields: true,
}
View Source 
var StorageCapabilityControllerTypeAnnotation = NewTypeAnnotation(StorageCapabilityControllerType)
View Source 
var StorageCapabilityControllerTypeBorrowTypeFieldType = MetaType
View Source 
var StorageCapabilityControllerTypeCapabilityFieldType = &CapabilityType{}
View Source 
var StorageCapabilityControllerTypeCapabilityIDFieldType = UInt64Type
View Source 
var StorageCapabilityControllerTypeDeleteFunctionType = &FunctionType{
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var StorageCapabilityControllerTypeRetargetFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "target",
			TypeAnnotation: NewTypeAnnotation(StoragePathType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var StorageCapabilityControllerTypeSetTagFunctionType = &FunctionType{
	Parameters: []Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "tag",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
	},
	ReturnTypeAnnotation: NewTypeAnnotation(
		VoidType,
	),
}
View Source 
var StorageCapabilityControllerTypeTagFieldType = StringType
View Source 
var StorageCapabilityControllerTypeTargetFunctionType = &FunctionType{
	ReturnTypeAnnotation: NewTypeAnnotation(
		StoragePathType,
	),
}
View Source 
var StoragePathConversionFunctionType = pathConversionFunctionType(StoragePathType)
View Source 
var StoragePathType = &SimpleType{
	Name:          "StoragePath",
	QualifiedName: "StoragePath",
	TypeID:        "StoragePath",
	TypeTag:       StoragePathTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    false,
	Exportable:    true,
	Importable:    true,
	conformances: []*InterfaceType{
		StructStringerType,
	},
}

StoragePathType

View Source 
var StoragePathTypeAnnotation = NewTypeAnnotation(StoragePathType)
View Source 
var StorageType = &EntitlementType{
	Identifier: "Storage",
}
View Source 
var StringFunctionType = func() *FunctionType {

	typeName := StringType.String()

	if BaseValueActivation.Find(typeName) != nil {
		panic(errors.NewUnreachableError())
	}

	functionType := NewSimpleFunctionType(
		FunctionPurityView,
		nil,
		StringTypeAnnotation,
	)

	addMember := func(member *Member) {
		if functionType.Members == nil {
			functionType.Members = &StringMemberOrderedMap{}
		}
		name := member.Identifier.Identifier
		if functionType.Members.Contains(name) {
			panic(errors.NewUnreachableError())
		}
		functionType.Members.Set(name, member)
	}

	addMember(NewUnmeteredPublicFunctionMember(
		functionType,
		StringTypeEncodeHexFunctionName,
		StringTypeEncodeHexFunctionType,
		StringTypeEncodeHexFunctionDocString,
	))

	addMember(NewUnmeteredPublicFunctionMember(
		functionType,
		StringTypeFromUtf8FunctionName,
		StringTypeFromUtf8FunctionType,
		StringTypeFromUtf8FunctionDocString,
	))

	addMember(NewUnmeteredPublicFunctionMember(
		functionType,
		StringTypeFromCharactersFunctionName,
		StringTypeFromCharactersFunctionType,
		StringTypeFromCharactersFunctionDocString,
	))

	addMember(NewUnmeteredPublicFunctionMember(
		functionType,
		StringTypeJoinFunctionName,
		StringTypeJoinFunctionType,
		StringTypeJoinFunctionDocString,
	))

	BaseValueActivation.Set(
		typeName,
		baseFunctionVariable(
			typeName,
			functionType,
			stringFunctionDocString,
		),
	)

	return functionType
}()
View Source 
var StringType = &SimpleType{
	Name:          "String",
	QualifiedName: "String",
	TypeID:        "String",
	TypeTag:       StringTypeTag,
	IsResource:    false,
	Storable:      true,
	Primitive:     true,
	Equatable:     true,
	Comparable:    true,
	Exportable:    true,
	Importable:    true,
	ValueIndexingInfo: ValueIndexingInfo{
		IsValueIndexableType:          true,
		AllowsValueIndexingAssignment: false,
		ElementType: func(_ bool) Type {
			return CharacterType
		},
		IndexingType: IntegerType,
	},
	conformances: []*InterfaceType{
		StructStringerType,
	},
}

StringType represents the string type

View Source 
var StringTypeAnnotation = NewTypeAnnotation(StringType)
View Source 
var StringTypeConcatFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "other",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	StringTypeAnnotation,
)
View Source 
var StringTypeContainsFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "other",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	BoolTypeAnnotation,
)
View Source 
var StringTypeCountFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "other",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	IntTypeAnnotation,
)
View Source 
var StringTypeDecodeHexFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	nil,
	ByteArrayTypeAnnotation,
)
View Source 
var StringTypeEncodeHexFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "data",
			TypeAnnotation: ByteArrayTypeAnnotation,
		},
	},
	StringTypeAnnotation,
)
View Source 
var StringTypeFromCharactersFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "characters",
			TypeAnnotation: NewTypeAnnotation(&VariableSizedType{
				Type: CharacterType,
			}),
		},
	},
	StringTypeAnnotation,
)
View Source 
var StringTypeFromUtf8FunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "bytes",
			TypeAnnotation: ByteArrayTypeAnnotation,
		},
	},
	NewTypeAnnotation(
		&OptionalType{
			Type: StringType,
		},
	),
)
View Source 
var StringTypeIndexFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          "of",
			Identifier:     "other",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	IntTypeAnnotation,
)
View Source 
var StringTypeJoinFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:      ArgumentLabelNotRequired,
			Identifier: "strings",
			TypeAnnotation: NewTypeAnnotation(&VariableSizedType{
				Type: StringType,
			}),
		},
		{
			Identifier:     "separator",
			TypeAnnotation: NewTypeAnnotation(StringType),
		},
	},
	StringTypeAnnotation,
)
View Source 
var StringTypeReplaceAllFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          "of",
			Identifier:     "old",
			TypeAnnotation: StringTypeAnnotation,
		},
		{
			Label:          "with",
			Identifier:     "replacement",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	StringTypeAnnotation,
)
View Source 
var StringTypeSliceFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier:     "from",
			TypeAnnotation: IntTypeAnnotation,
		},
		{
			Identifier:     "upTo",
			TypeAnnotation: IntTypeAnnotation,
		},
	},
	StringTypeAnnotation,
)
View Source 
var StringTypeSplitFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Identifier:     "separator",
			TypeAnnotation: StringTypeAnnotation,
		},
	},
	NewTypeAnnotation(
		&VariableSizedType{
			Type: StringType,
		},
	),
)
View Source 
var StringTypeToLowerFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	nil,
	StringTypeAnnotation,
)
View Source 
var StructStringerType = func() *InterfaceType {
	var t = &InterfaceType{
		Identifier:    StructStringerTypeName,
		CompositeKind: common.CompositeKindStructure,
	}

	return t
}()
View Source 
var StructStringerTypeToStringFunctionType = &FunctionType{
	Purity: FunctionPurityView,
	ReturnTypeAnnotation: NewTypeAnnotation(
		StringType,
	),
}
View Source 
var TheAddressType = &AddressType{}
View Source 
var ToBigEndianBytesFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	nil,
	ByteArrayTypeAnnotation,
)
View Source 
var ToStringFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	nil,
	StringTypeAnnotation,
)
View Source 
var UnpublishCapabilityType = &EntitlementType{
	Identifier: "UnpublishCapability",
}
View Source 
var UnpublishInboxCapabilityType = &EntitlementType{
	Identifier: "UnpublishInboxCapability",
}
View Source 
var UpdateContractType = &EntitlementType{
	Identifier: "UpdateContract",
}
View Source 
var VariableSizedArrayTypeFunctionType = NewSimpleFunctionType(
	FunctionPurityView,
	[]Parameter{
		{
			Label:          ArgumentLabelNotRequired,
			Identifier:     "type",
			TypeAnnotation: MetaTypeAnnotation,
		},
	},
	MetaTypeAnnotation,
)
View Source 
var VoidType = &SimpleType{
	Name:          "Void",
	QualifiedName: "Void",
	TypeID:        "Void",
	TypeTag:       VoidTypeTag,
	IsResource:    false,
	Storable:      false,
	Primitive:     true,
	Equatable:     true,
	Comparable:    false,
	Exportable:    true,
	Importable:    false,
}

VoidType represents the void type

View Source 
var VoidTypeAnnotation = NewTypeAnnotation(VoidType)

Functions

func AreCompatibleEquatableTypes 

func AreCompatibleEquatableTypes(leftType, rightType Type) bool

func CheckAddressLiteral 

func CheckAddressLiteral(memoryGauge common.MemoryGauge, expression *ast.IntegerExpression, report func(error)) bool

CheckAddressLiteral checks that the value of the integer literal fits into the range of an address (64 bits), and is hexadecimal

func CheckFixedPointLiteral 

func CheckFixedPointLiteral(
	memoryGauge common.MemoryGauge,
	expression *ast.FixedPointExpression,
	targetType Type,
	report func(error),
) bool

CheckFixedPointLiteral checks that the value of the fixed-point literal fits into range of the target fixed-point type

func CheckIntegerLiteral 

func CheckIntegerLiteral(memoryGauge common.MemoryGauge, expression *ast.IntegerExpression, targetType Type, report func(error)) bool

CheckIntegerLiteral checks that the value of the integer literal fits into range of the target integer type

func CheckParameterizedTypeInstantiated 

func CheckParameterizedTypeInstantiated(
	t ParameterizedType,
	pos ast.HasPosition,
	memoryGauge common.MemoryGauge,
	report func(err error),
)

func ErrorMessageExpectedActualTypes 

func ErrorMessageExpectedActualTypes(
	expectedType Type,
	actualType Type,
) (
	expected string,
	actual string,
)

func FailableCastCanSucceed 

func FailableCastCanSucceed(subType, superType Type) bool

FailableCastCanSucceed checks a failable (dynamic) cast, i.e. a cast that might succeed at run-time. It returns true if the cast from subType to superType could potentially succeed at run-time, and returns false if the cast will definitely always fail.

func FormatCapabilityTypeID 

func FormatCapabilityTypeID[T ~string](borrowTypeID T) T

func FormatConstantSizedTypeID 

func FormatConstantSizedTypeID[T ~string](elementTypeID T, size int64) T

func FormatDictionaryTypeID 

func FormatDictionaryTypeID[T ~string](keyTypeID T, valueTypeID T) T

func FormatEntitlementSetTypeID 

func FormatEntitlementSetTypeID[T ~string](entitlementTypeIDs []T, kind EntitlementSetKind) T

func FormatFunctionTypeID 

func FormatFunctionTypeID(
	purity string,
	typeParameters []string,
	parameters []string,
	returnTypeAnnotation string,
) string

func FormatIntersectionTypeID 

func FormatIntersectionTypeID[T ~string](interfaceTypeIDs []T) T

func FormatOptionalTypeID 

func FormatOptionalTypeID[T ~string](elementTypeID T) T

func FormatReferenceTypeID 

func FormatReferenceTypeID[T ~string](authorization T, borrowTypeID T) T

func FormatVariableSizedTypeID 

func FormatVariableSizedTypeID[T ~string](elementTypeID T) T

func FromBigEndianBytesFunctionDocstring 

func FromBigEndianBytesFunctionDocstring(ty Type) string

func FromStringFunctionDocstring 

func FromStringFunctionDocstring(ty Type) string

func FunctionEntryPointDeclaration 

func FunctionEntryPointDeclaration(program *ast.Program) *ast.FunctionDeclaration

FunctionEntryPointDeclaration returns the entry point function declaration, if any.

Returns nil if there are multiple function declarations with the same function entry point name, or a transaction declaration.

func IsHashableStructType 

func IsHashableStructType(t Type) bool

func IsNilType 

func IsNilType(ty Type) bool

IsNilType returns true if the given type is the type of `nil`, i.e. `Never?`.

func IsPrimitiveOrContainerOfPrimitive 

func IsPrimitiveOrContainerOfPrimitive(referencedType Type) bool

func IsProperSubType 

func IsProperSubType(subType Type, superType Type) bool

IsProperSubType is similar to IsSubType, i.e. it determines if the given subtype is a subtype of the given supertype, but returns false if the subtype and supertype refer to the same type.

func IsSameTypeKind 

func IsSameTypeKind(subType Type, superType Type) bool

IsSameTypeKind determines if the given subtype belongs to the same kind as the supertype.

e.g: 'Never' type is a subtype of 'Integer', but not of the same kind as 'Integer'. Whereas, 'Int8' is both a subtype and also of same kind as 'Integer'.

func IsSubType 

func IsSubType(subType Type, superType Type) bool

IsSubType determines if the given subtype is a subtype of the given supertype.

Types are subtypes of themselves.

NOTE: This method can be used to check the assignability of `subType` to `superType`. However, to check if a type *strictly* belongs to a certain category, then consider using `IsSameTypeKind` method. e.g: "Is type `T` an Integer type?". Using this method for the later use-case may produce incorrect results.

The differences between these methods is as follows:

  • IsSubType():

    To check the assignability, e.g: is argument type T is a sub-type of parameter type R? This is the more frequent use-case.

  • IsSameTypeKind():

    To check if a type strictly belongs to a certain category. e.g: Is the expression type T is any of the integer types, but nothing else. Another way to check is, asking the question of "if the subType is Never, should the check still pass?". A common code-smell for potential incorrect usage is, using IsSubType() method with a constant/pre-defined superType. e.g: IsSubType(<<someType>>, FixedPointType)

func IsValidAssignmentTargetExpression 

func IsValidAssignmentTargetExpression(expression ast.Expression) bool

func IsValidCharacter 

func IsValidCharacter(s string) bool

func IsValidEventParameterType 

func IsValidEventParameterType(t Type, results map[*Member]bool) bool

IsValidEventParameterType returns true if the given type is a valid event parameter type.

Events currently only support a few simple Cadence types.

func MembersAsResolvers 

func MembersAsResolvers(members []*Member) map[string]MemberResolver

func MembersFieldNames 

func MembersFieldNames(members []*Member) []string

func MembersMapAsResolvers 

func MembersMapAsResolvers(members *StringMemberOrderedMap) map[string]MemberResolver

func VisitThisAndNested 

func VisitThisAndNested(t Type, visit func(ty Type))

Types

type Access 

type Access interface {
	IsPrimitiveAccess() bool
	ID() TypeID
	String() string
	QualifiedString() string
	Equal(other Access) bool
	// PermitsAccess returns whether receiver access permits argument access
	PermitsAccess(Access) bool
	QualifiedKeyword() string
	// contains filtered or unexported methods
}
var InaccessibleAccess Access = PrimitiveAccess(ast.AccessNone)
var UnauthorizedAccess Access = PrimitiveAccess(ast.AccessAll)

func AllSupportedEntitlements 

func AllSupportedEntitlements(typ Type) Access

func NewAccessFromEntitlementOrderedSet 

func NewAccessFromEntitlementOrderedSet(
	set *EntitlementOrderedSet,
	setKind EntitlementSetKind,
) Access

type AccessCheckMode 

type AccessCheckMode uint
const (
	// AccessCheckModeDefault indicates the default access check mode should be used.
	AccessCheckModeDefault AccessCheckMode = iota
	// AccessCheckModeStrict indicates that access modifiers are required
	// and access checks are always enforced.
	AccessCheckModeStrict
	// AccessCheckModeNotSpecifiedRestricted indicates modifiers are optional.
	// Access is assumed private if not specified
	AccessCheckModeNotSpecifiedRestricted
	// AccessCheckModeNotSpecifiedUnrestricted indicates access modifiers are optional.
	// Access is assumed public if not specified
	AccessCheckModeNotSpecifiedUnrestricted
	// AccessCheckModeNone indicates access modifiers are optional and ignored.
	AccessCheckModeNone
)

func (AccessCheckMode) IsReadableAccess 

func (mode AccessCheckMode) IsReadableAccess(access Access) bool

func (AccessCheckMode) IsWriteableAccess 

func (mode AccessCheckMode) IsWriteableAccess(access Access) bool

func (AccessCheckMode) String 

func (i AccessCheckMode) String() string

type ActivationHandlerFunc 

type ActivationHandlerFunc func(common.Location) *VariableActivation

type AddressContractNamesResolver 

type AddressContractNamesResolver func(address common.Address) ([]string, error)

type AddressType 

type AddressType struct {
	// contains filtered or unexported fields
}

AddressType represents the address type

func (*AddressType) AddressInterfaceConformanceSet added in v1.3.0 

func (t *AddressType) AddressInterfaceConformanceSet() *InterfaceSet

func (*AddressType) CheckInstantiated 

func (*AddressType) CheckInstantiated(_ ast.HasPosition, _ common.MemoryGauge, _ func(err error))

func (*AddressType) ContainFieldsOrElements 

func (*AddressType) ContainFieldsOrElements() bool

func (*AddressType) Equal 

func (*AddressType) Equal(other Type) bool

func (*AddressType) GetMembers 

func (t *AddressType) GetMembers() map[string]MemberResolver

func (*AddressType) ID 

func (*AddressType) ID() TypeID

func (*AddressType) IsComparable 

func (*AddressType) IsComparable() bool

func (*AddressType) IsEquatable 

func (*AddressType) IsEquatable() bool

func (*AddressType) IsExportable 

func (*AddressType) IsExportable(_ map[*Member]bool) bool

func (*AddressType) IsImportable 

func (t *AddressType) IsImportable(_ map[*Member]bool) bool

func (*AddressType) IsInvalidType 

func (*AddressType) IsInvalidType() bool

func (*AddressType) IsOrContainsReferenceType 

func (*AddressType) IsOrContainsReferenceType() bool

func (*AddressType) IsPrimitiveType 

func (*AddressType) IsPrimitiveType() bool

func (*AddressType) IsResourceType 

func (*AddressType) IsResourceType() bool

func (*AddressType) IsStorable 

func (*AddressType) IsStorable(_ map[*Member]bool) bool

func (*AddressType) IsSuperType 

func (*AddressType) IsSuperType() bool

func (*AddressType) IsType 

func (*AddressType) IsType()

func (*AddressType) Map 

func (t *AddressType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*AddressType) MaxInt 

func (*AddressType) MaxInt() *big.Int

func (*AddressType) MinInt 

func (*AddressType) MinInt() *big.Int

func (*AddressType) QualifiedString 

func (*AddressType) QualifiedString() string

func (*AddressType) Resolve 

func (t *AddressType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*AddressType) RewriteWithIntersectionTypes 

func (t *AddressType) RewriteWithIntersectionTypes() (Type, bool)

func (*AddressType) String 

func (*AddressType) String() string

func (*AddressType) Tag 

func (t *AddressType) Tag() TypeTag

func (*AddressType) TypeAnnotationState 

func (*AddressType) TypeAnnotationState() TypeAnnotationState

func (*AddressType) Unify 

func (*AddressType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type AlwaysFailingNonResourceCastingTypeError 

type AlwaysFailingNonResourceCastingTypeError struct {
	ValueType  Type
	TargetType Type
	ast.Range
}

func (*AlwaysFailingNonResourceCastingTypeError) Error 

func (e *AlwaysFailingNonResourceCastingTypeError) Error() string

func (*AlwaysFailingNonResourceCastingTypeError) IsUserError 

func (*AlwaysFailingNonResourceCastingTypeError) IsUserError()

type AlwaysFailingResourceCastingTypeError 

type AlwaysFailingResourceCastingTypeError struct {
	ValueType  Type
	TargetType Type
	ast.Range
}

func (*AlwaysFailingResourceCastingTypeError) Error 

func (e *AlwaysFailingResourceCastingTypeError) Error() string

func (*AlwaysFailingResourceCastingTypeError) IsUserError 

func (*AlwaysFailingResourceCastingTypeError) IsUserError()

type AmbiguousIntersectionTypeError 

type AmbiguousIntersectionTypeError struct {
	ast.Range
}

func (*AmbiguousIntersectionTypeError) Error 

func (e *AmbiguousIntersectionTypeError) Error() string

func (*AmbiguousIntersectionTypeError) IsUserError 

func (*AmbiguousIntersectionTypeError) IsUserError()

type ArgumentExpressionsCheck 

type ArgumentExpressionsCheck func(
	checker *Checker,
	argumentExpressions []ast.Expression,
	invocationRange ast.HasPosition,
)

type Arity 

type Arity struct {
	Min int
	Max int
}

func (*Arity) MaxCount 

func (arity *Arity) MaxCount(parameterCount int) *int

func (*Arity) MinCount 

func (arity *Arity) MinCount(parameterCount int) int

type ArrayExpressionTypes 

type ArrayExpressionTypes struct {
	ArrayType     ArrayType
	ArgumentTypes []Type
}

type ArrayType 

type ArrayType interface {
	ValueIndexableType
	EntitlementSupportingType
	// contains filtered or unexported methods
}

type AssignmentStatementTypes 

type AssignmentStatementTypes struct {
	ValueType  Type
	TargetType Type
}

type AssignmentToConstantError 

type AssignmentToConstantError struct {
	Name string
	ast.Range
}

func (*AssignmentToConstantError) Error 

func (e *AssignmentToConstantError) Error() string

func (*AssignmentToConstantError) IsUserError 

func (*AssignmentToConstantError) IsUserError()

func (*AssignmentToConstantError) SecondaryError 

func (e *AssignmentToConstantError) SecondaryError() string

type AssignmentToConstantMemberError 

type AssignmentToConstantMemberError struct {
	Name string
	ast.Range
}

func (*AssignmentToConstantMemberError) Error 

func (e *AssignmentToConstantMemberError) Error() string

func (*AssignmentToConstantMemberError) IsUserError 

func (*AssignmentToConstantMemberError) IsUserError()

type AttachNonAttachmentError 

type AttachNonAttachmentError struct {
	Type Type
	ast.Range
}

func (*AttachNonAttachmentError) Error 

func (e *AttachNonAttachmentError) Error() string

func (*AttachNonAttachmentError) IsUserError 

func (*AttachNonAttachmentError) IsUserError()

type AttachToInvalidTypeError 

type AttachToInvalidTypeError struct {
	Type Type
	ast.Range
}

AttachToInvalidTypeError

func (*AttachToInvalidTypeError) Error 

func (e *AttachToInvalidTypeError) Error() string

func (*AttachToInvalidTypeError) IsUserError 

func (*AttachToInvalidTypeError) IsUserError()

type BeforeExtractor 

type BeforeExtractor struct {
	ExpressionExtractor *ast.ExpressionExtractor
	// contains filtered or unexported fields
}

func NewBeforeExtractor 

func NewBeforeExtractor(memoryGauge common.MemoryGauge, report func(error)) *BeforeExtractor

func (*BeforeExtractor) ExtractBefore 

func (e *BeforeExtractor) ExtractBefore(expression ast.Expression) ast.ExpressionExtraction

func (*BeforeExtractor) ExtractFunction 

func (e *BeforeExtractor) ExtractFunction(
	_ *ast.ExpressionExtractor,
	expression *ast.FunctionExpression,
) ast.ExpressionExtraction

func (*BeforeExtractor) ExtractInvocation 

func (e *BeforeExtractor) ExtractInvocation(
	extractor *ast.ExpressionExtractor,
	expression *ast.InvocationExpression,
) ast.ExpressionExtraction

type BinaryExpressionTypes 

type BinaryExpressionTypes struct {
	ResultType Type
	LeftType   Type
	RightType  Type
}

type BinaryOperationKind 

type BinaryOperationKind uint
const (
	BinaryOperationKindUnknown BinaryOperationKind = iota
	BinaryOperationKindArithmetic
	BinaryOperationKindNonEqualityComparison
	BinaryOperationKindBooleanLogic
	BinaryOperationKindEquality
	BinaryOperationKindNilCoalescing
	BinaryOperationKindBitwise
)

func (BinaryOperationKind) String 

func (i BinaryOperationKind) String() string

type CapabilityType 

type CapabilityType struct {
	BorrowType Type
	// contains filtered or unexported fields
}

func NewCapabilityType 

func NewCapabilityType(memoryGauge common.MemoryGauge, borrowType Type) *CapabilityType

func (*CapabilityType) BaseType 

func (t *CapabilityType) BaseType() Type

func (*CapabilityType) CheckInstantiated 

func (t *CapabilityType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*CapabilityType) ContainFieldsOrElements 

func (*CapabilityType) ContainFieldsOrElements() bool

func (*CapabilityType) Equal 

func (t *CapabilityType) Equal(other Type) bool

func (*CapabilityType) GetMembers 

func (t *CapabilityType) GetMembers() map[string]MemberResolver

func (*CapabilityType) ID 

func (t *CapabilityType) ID() TypeID

func (*CapabilityType) Instantiate 

func (t *CapabilityType) Instantiate(
	_ common.MemoryGauge,
	typeArguments []Type,
	_ []*ast.TypeAnnotation,
	_ func(err error),
) Type

func (*CapabilityType) IsComparable 

func (*CapabilityType) IsComparable() bool

func (*CapabilityType) IsEquatable 

func (*CapabilityType) IsEquatable() bool

func (*CapabilityType) IsExportable 

func (*CapabilityType) IsExportable(_ map[*Member]bool) bool

func (*CapabilityType) IsImportable 

func (t *CapabilityType) IsImportable(_ map[*Member]bool) bool

func (*CapabilityType) IsInvalidType 

func (t *CapabilityType) IsInvalidType() bool

func (*CapabilityType) IsOrContainsReferenceType 

func (t *CapabilityType) IsOrContainsReferenceType() bool

func (*CapabilityType) IsPrimitiveType 

func (*CapabilityType) IsPrimitiveType() bool

func (*CapabilityType) IsResourceType 

func (*CapabilityType) IsResourceType() bool

func (*CapabilityType) IsStorable 

func (*CapabilityType) IsStorable(_ map[*Member]bool) bool

func (*CapabilityType) IsType 

func (*CapabilityType) IsType()

func (*CapabilityType) Map 

func (t *CapabilityType) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*CapabilityType) QualifiedString 

func (t *CapabilityType) QualifiedString() string

func (*CapabilityType) Resolve 

func (t *CapabilityType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*CapabilityType) RewriteWithIntersectionTypes 

func (t *CapabilityType) RewriteWithIntersectionTypes() (Type, bool)

func (*CapabilityType) String 

func (t *CapabilityType) String() string

func (*CapabilityType) Tag 

func (t *CapabilityType) Tag() TypeTag

func (*CapabilityType) TypeAnnotationState 

func (t *CapabilityType) TypeAnnotationState() TypeAnnotationState

func (*CapabilityType) TypeArguments 

func (t *CapabilityType) TypeArguments() []Type

func (*CapabilityType) TypeParameters 

func (t *CapabilityType) TypeParameters() []*TypeParameter

func (*CapabilityType) Unify 

func (t *CapabilityType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type CastTypes 

type CastTypes struct {
	ExprActualType Type
	TargetType     Type
	ExpectedType   Type
}

type CastingExpressionTypes 

type CastingExpressionTypes struct {
	StaticValueType Type
	TargetType      Type
}

type CheckHandlerFunc 

type CheckHandlerFunc func(checker *Checker, check func())

type Checker 

type Checker struct {
	Location common.Location

	Program      *ast.Program
	PositionInfo *PositionInfo
	Config       *Config
	Elaboration  *Elaboration
	// contains filtered or unexported fields
}

func NewChecker 

func NewChecker(
	program *ast.Program,
	location common.Location,
	memoryGauge common.MemoryGauge,
	config *Config,
) (*Checker, error)

func (*Checker) Check 

func (checker *Checker) Check() error

func (*Checker) CheckProgram 

func (checker *Checker) CheckProgram(program *ast.Program)

func (*Checker) CheckStatement 

func (checker *Checker) CheckStatement(element ast.Statement)

func (*Checker) CheckerError 

func (checker *Checker) CheckerError() *CheckerError

func (*Checker) ConvertType 

func (checker *Checker) ConvertType(t ast.Type) Type

ConvertType converts an AST type representation to a sema type

func (*Checker) ConvertTypeAnnotation 

func (checker *Checker) ConvertTypeAnnotation(typeAnnotation *ast.TypeAnnotation) TypeAnnotation

ConvertTypeAnnotation converts an AST type annotation representation to a sema type annotation

NOTE: type annotations are *NOT* checked!

func (*Checker) CurrentPurityScope 

func (checker *Checker) CurrentPurityScope() PurityCheckScope

func (*Checker) EffectiveCompositeMemberAccess 

func (checker *Checker) EffectiveCompositeMemberAccess(access Access) Access

func (*Checker) EnforcePurity 

func (checker *Checker) EnforcePurity(operation ast.Element, purity FunctionPurity)

func (*Checker) EntryPointParameters 

func (checker *Checker) EntryPointParameters() []Parameter

EntryPointParameters returns the parameters of the transaction or script, if any.

Returns nil if the program specifies both a valid transaction and entry point function declaration.

func (*Checker) InNewPurityScope 

func (checker *Checker) InNewPurityScope(enforce bool, f func())

func (*Checker) IsChecked 

func (checker *Checker) IsChecked() bool

func (*Checker) ObserveImpureOperation 

func (checker *Checker) ObserveImpureOperation(operation ast.Element)

func (*Checker) PopPurityScope 

func (checker *Checker) PopPurityScope() PurityCheckScope

func (*Checker) PushNewPurityScope 

func (checker *Checker) PushNewPurityScope(enforce bool, depth int)

func (*Checker) ResetErrors 

func (checker *Checker) ResetErrors()

func (*Checker) SetMemoryGauge 

func (checker *Checker) SetMemoryGauge(gauge common.MemoryGauge)

func (*Checker) SubChecker 

func (checker *Checker) SubChecker(program *ast.Program, location common.Location) (*Checker, error)

func (*Checker) TypeActivationDepth 

func (checker *Checker) TypeActivationDepth() int

func (*Checker) ValueActivationDepth 

func (checker *Checker) ValueActivationDepth() int

func (*Checker) VisitArrayExpression 

func (checker *Checker) VisitArrayExpression(arrayExpression *ast.ArrayExpression) Type

func (*Checker) VisitAssignmentStatement 

func (checker *Checker) VisitAssignmentStatement(assignment *ast.AssignmentStatement) (_ struct{})

func (*Checker) VisitAttachExpression 

func (checker *Checker) VisitAttachExpression(expression *ast.AttachExpression) Type

func (*Checker) VisitAttachmentDeclaration 

func (checker *Checker) VisitAttachmentDeclaration(declaration *ast.AttachmentDeclaration) (_ struct{})

func (*Checker) VisitBinaryExpression 

func (checker *Checker) VisitBinaryExpression(expression *ast.BinaryExpression) Type

func (*Checker) VisitBoolExpression 

func (checker *Checker) VisitBoolExpression(_ *ast.BoolExpression) Type

func (*Checker) VisitBreakStatement 

func (checker *Checker) VisitBreakStatement(statement *ast.BreakStatement) (_ struct{})

func (*Checker) VisitCastingExpression 

func (checker *Checker) VisitCastingExpression(expression *ast.CastingExpression) Type

func (*Checker) VisitCompositeDeclaration 

func (checker *Checker) VisitCompositeDeclaration(declaration *ast.CompositeDeclaration) (_ struct{})

func (*Checker) VisitConditionalExpression 

func (checker *Checker) VisitConditionalExpression(expression *ast.ConditionalExpression) Type

func (*Checker) VisitContinueStatement 

func (checker *Checker) VisitContinueStatement(statement *ast.ContinueStatement) (_ struct{})

func (*Checker) VisitCreateExpression 

func (checker *Checker) VisitCreateExpression(expression *ast.CreateExpression) Type

func (*Checker) VisitDestroyExpression 

func (checker *Checker) VisitDestroyExpression(expression *ast.DestroyExpression) (resultType Type)

func (*Checker) VisitDictionaryExpression 

func (checker *Checker) VisitDictionaryExpression(expression *ast.DictionaryExpression) Type

func (*Checker) VisitEmitStatement 

func (checker *Checker) VisitEmitStatement(statement *ast.EmitStatement) (_ struct{})

func (*Checker) VisitEntitlementDeclaration 

func (checker *Checker) VisitEntitlementDeclaration(declaration *ast.EntitlementDeclaration) (_ struct{})

func (*Checker) VisitEntitlementMappingDeclaration 

func (checker *Checker) VisitEntitlementMappingDeclaration(declaration *ast.EntitlementMappingDeclaration) (_ struct{})

func (*Checker) VisitEnumCaseDeclaration 

func (checker *Checker) VisitEnumCaseDeclaration(_ *ast.EnumCaseDeclaration) struct{}

func (*Checker) VisitExpression 

func (checker *Checker) VisitExpression(expr ast.Expression, parent ast.Element, expectedType Type) Type

func (*Checker) VisitExpressionStatement 

func (checker *Checker) VisitExpressionStatement(statement *ast.ExpressionStatement) (_ struct{})

func (*Checker) VisitExpressionWithForceType 

func (checker *Checker) VisitExpressionWithForceType(expr ast.Expression, parent ast.Element, expectedType Type, forceType bool) Type

func (*Checker) VisitExpressionWithReferenceCheck 

func (checker *Checker) VisitExpressionWithReferenceCheck(expr ast.Expression, parent ast.Element, targetType Type) Type

func (*Checker) VisitFieldDeclaration 

func (checker *Checker) VisitFieldDeclaration(_ *ast.FieldDeclaration) struct{}

func (*Checker) VisitFixedPointExpression 

func (checker *Checker) VisitFixedPointExpression(expression *ast.FixedPointExpression) Type

func (*Checker) VisitForStatement 

func (checker *Checker) VisitForStatement(statement *ast.ForStatement) (_ struct{})

func (*Checker) VisitForceExpression 

func (checker *Checker) VisitForceExpression(expression *ast.ForceExpression) Type

func (*Checker) VisitFunctionDeclaration 

func (checker *Checker) VisitFunctionDeclaration(declaration *ast.FunctionDeclaration) (_ struct{})

func (*Checker) VisitFunctionExpression 

func (checker *Checker) VisitFunctionExpression(expression *ast.FunctionExpression) Type

func (*Checker) VisitIdentifierExpression 

func (checker *Checker) VisitIdentifierExpression(expression *ast.IdentifierExpression) Type

func (*Checker) VisitIfStatement 

func (checker *Checker) VisitIfStatement(statement *ast.IfStatement) (_ struct{})

func (*Checker) VisitImportDeclaration 

func (checker *Checker) VisitImportDeclaration(declaration *ast.ImportDeclaration) struct{}

func (*Checker) VisitIndexExpression 

func (checker *Checker) VisitIndexExpression(expression *ast.IndexExpression) Type

func (*Checker) VisitIntegerExpression 

func (checker *Checker) VisitIntegerExpression(expression *ast.IntegerExpression) Type

func (*Checker) VisitInterfaceDeclaration 

func (checker *Checker) VisitInterfaceDeclaration(declaration *ast.InterfaceDeclaration) (_ struct{})

VisitInterfaceDeclaration checks the given interface declaration.

NOTE: This function assumes that the interface type was previously declared using `declareInterfaceType` and exists in `checker.Elaboration.InterfaceDeclarationTypes`, and that the members and nested declarations for the interface type were declared through `declareInterfaceMembers`.

func (*Checker) VisitInvocationExpression 

func (checker *Checker) VisitInvocationExpression(invocationExpression *ast.InvocationExpression) Type

func (*Checker) VisitMemberExpression 

func (checker *Checker) VisitMemberExpression(expression *ast.MemberExpression) Type

NOTE: only called if the member expression is *not* an assignment

func (*Checker) VisitNilExpression 

func (checker *Checker) VisitNilExpression(_ *ast.NilExpression) Type

func (*Checker) VisitPathExpression 

func (checker *Checker) VisitPathExpression(expression *ast.PathExpression) Type

func (*Checker) VisitPragmaDeclaration 

func (checker *Checker) VisitPragmaDeclaration(declaration *ast.PragmaDeclaration) (_ struct{})

VisitPragmaDeclaration checks that the pragma declaration is valid. It is valid if the root expression is an identifier or invocation. Invocations must

func (*Checker) VisitReferenceExpression 

func (checker *Checker) VisitReferenceExpression(referenceExpression *ast.ReferenceExpression) Type

VisitReferenceExpression checks a reference expression

func (*Checker) VisitRemoveStatement 

func (checker *Checker) VisitRemoveStatement(statement *ast.RemoveStatement) (_ struct{})

func (*Checker) VisitReturnStatement 

func (checker *Checker) VisitReturnStatement(statement *ast.ReturnStatement) (_ struct{})

func (*Checker) VisitSpecialFunctionDeclaration 

func (checker *Checker) VisitSpecialFunctionDeclaration(declaration *ast.SpecialFunctionDeclaration) struct{}

func (*Checker) VisitStringExpression 

func (checker *Checker) VisitStringExpression(expression *ast.StringExpression) Type

func (*Checker) VisitStringTemplateExpression added in v1.3.0 

func (checker *Checker) VisitStringTemplateExpression(stringTemplateExpression *ast.StringTemplateExpression) Type

func (*Checker) VisitSwapStatement 

func (checker *Checker) VisitSwapStatement(swap *ast.SwapStatement) (_ struct{})

func (*Checker) VisitSwitchStatement 

func (checker *Checker) VisitSwitchStatement(statement *ast.SwitchStatement) (_ struct{})

func (*Checker) VisitTransactionDeclaration 

func (checker *Checker) VisitTransactionDeclaration(declaration *ast.TransactionDeclaration) (_ struct{})

func (*Checker) VisitUnaryExpression 

func (checker *Checker) VisitUnaryExpression(expression *ast.UnaryExpression) Type

func (*Checker) VisitVariableDeclaration 

func (checker *Checker) VisitVariableDeclaration(declaration *ast.VariableDeclaration) (_ struct{})

func (*Checker) VisitVoidExpression 

func (checker *Checker) VisitVoidExpression(_ *ast.VoidExpression) Type

func (*Checker) VisitWhileStatement 

func (checker *Checker) VisitWhileStatement(statement *ast.WhileStatement) (_ struct{})

type CheckerError 

type CheckerError struct {
	Location common.Location
	Codes    map[common.Location][]byte
	Errors   []error
}

func (CheckerError) ChildErrors 

func (e CheckerError) ChildErrors() []error

func (CheckerError) Error 

func (e CheckerError) Error() string

func (CheckerError) ImportLocation 

func (e CheckerError) ImportLocation() common.Location

func (CheckerError) IsUserError 

func (CheckerError) IsUserError()

func (CheckerError) Unwrap 

func (e CheckerError) Unwrap() []error

type CompositeKindMismatchError 

type CompositeKindMismatchError struct {
	ExpectedKind common.CompositeKind
	ActualKind   common.CompositeKind
	ast.Range
}

func (*CompositeKindMismatchError) Error 

func (e *CompositeKindMismatchError) Error() string

func (*CompositeKindMismatchError) IsUserError 

func (*CompositeKindMismatchError) IsUserError()

func (*CompositeKindMismatchError) SecondaryError 

func (e *CompositeKindMismatchError) SecondaryError() string

type CompositeKindedType 

type CompositeKindedType interface {
	Type
	EntitlementSupportingType
	GetCompositeKind() common.CompositeKind
}

CompositeKindedType is a type which has a composite kind

type CompositeType 

type CompositeType struct {
	Location    common.Location
	EnumRawType Type

	NestedTypes *StringTypeOrderedMap

	DefaultDestroyEvent *CompositeType

	Members *StringMemberOrderedMap

	Identifier            string
	Fields                []string
	ConstructorParameters []Parameter

	ExplicitInterfaceConformances []*InterfaceType
	Kind                          common.CompositeKind

	ConstructorPurity  FunctionPurity
	HasComputedMembers bool
	// Only applicable for native composite types
	ImportableBuiltin bool
	// contains filtered or unexported fields
}

func (*CompositeType) CheckInstantiated 

func (t *CompositeType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*CompositeType) ConstructorFunctionType 

func (t *CompositeType) ConstructorFunctionType() *FunctionType

func (*CompositeType) ContainFieldsOrElements 

func (t *CompositeType) ContainFieldsOrElements() bool

func (*CompositeType) EffectiveInterfaceConformanceSet 

func (t *CompositeType) EffectiveInterfaceConformanceSet() *InterfaceSet

func (*CompositeType) EffectiveInterfaceConformances 

func (t *CompositeType) EffectiveInterfaceConformances() []Conformance

func (*CompositeType) Equal 

func (t *CompositeType) Equal(other Type) bool

func (*CompositeType) FieldPosition 

func (t *CompositeType) FieldPosition(name string, declaration ast.CompositeLikeDeclaration) ast.Position

func (*CompositeType) GetBaseType 

func (t *CompositeType) GetBaseType() Type

func (*CompositeType) GetCompositeKind 

func (t *CompositeType) GetCompositeKind() common.CompositeKind

func (*CompositeType) GetContainerType 

func (t *CompositeType) GetContainerType() Type

func (*CompositeType) GetLocation 

func (t *CompositeType) GetLocation() common.Location

func (*CompositeType) GetMembers 

func (t *CompositeType) GetMembers() map[string]MemberResolver

func (*CompositeType) GetNestedTypes 

func (t *CompositeType) GetNestedTypes() *StringTypeOrderedMap

func (*CompositeType) ID 

func (t *CompositeType) ID() TypeID

func (*CompositeType) InitializerEffectiveArgumentLabels 

func (t *CompositeType) InitializerEffectiveArgumentLabels() []string

func (*CompositeType) InitializerFunctionType 

func (t *CompositeType) InitializerFunctionType() *FunctionType

func (*CompositeType) IsComparable 

func (*CompositeType) IsComparable() bool

func (*CompositeType) IsContainerType 

func (t *CompositeType) IsContainerType() bool

func (*CompositeType) IsEquatable 

func (t *CompositeType) IsEquatable() bool

func (*CompositeType) IsExportable 

func (t *CompositeType) IsExportable(results map[*Member]bool) bool

func (*CompositeType) IsImportable 

func (t *CompositeType) IsImportable(results map[*Member]bool) bool

func (*CompositeType) IsInvalidType 

func (*CompositeType) IsInvalidType() bool

func (*CompositeType) IsOrContainsReferenceType 

func (*CompositeType) IsOrContainsReferenceType() bool

func (*CompositeType) IsPrimitiveType 

func (t *CompositeType) IsPrimitiveType() bool

func (*CompositeType) IsResourceType 

func (t *CompositeType) IsResourceType() bool

func (*CompositeType) IsStorable 

func (t *CompositeType) IsStorable(results map[*Member]bool) bool

func (*CompositeType) IsType 

func (*CompositeType) IsType()

func (*CompositeType) IsValidIndexingType 

func (t *CompositeType) IsValidIndexingType(ty Type) bool

func (*CompositeType) Map 

func (t *CompositeType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*CompositeType) MemberMap 

func (t *CompositeType) MemberMap() *StringMemberOrderedMap

func (*CompositeType) QualifiedIdentifier 

func (t *CompositeType) QualifiedIdentifier() string

func (*CompositeType) QualifiedString 

func (t *CompositeType) QualifiedString() string

func (*CompositeType) Resolve 

func (t *CompositeType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*CompositeType) ResolveMembers 

func (t *CompositeType) ResolveMembers()

func (*CompositeType) RewriteWithIntersectionTypes 

func (t *CompositeType) RewriteWithIntersectionTypes() (result Type, rewritten bool)

func (*CompositeType) SetContainerType 

func (t *CompositeType) SetContainerType(containerType Type)

func (*CompositeType) SetNestedType 

func (t *CompositeType) SetNestedType(name string, nestedType ContainedType)

func (*CompositeType) String 

func (t *CompositeType) String() string

func (*CompositeType) SupportedEntitlements 

func (t *CompositeType) SupportedEntitlements() *EntitlementSet

func (*CompositeType) Tag 

func (t *CompositeType) Tag() TypeTag

func (*CompositeType) TypeAnnotationState 

func (t *CompositeType) TypeAnnotationState() TypeAnnotationState

func (*CompositeType) TypeIndexingElementType 

func (t *CompositeType) TypeIndexingElementType(indexingType Type, _ func() ast.Range) (Type, error)

func (*CompositeType) Unify 

func (*CompositeType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type Config 

type Config struct {
	// ContractValueHandler is used to construct the contract variable
	ContractValueHandler ContractValueHandlerFunc
	// MemberAccountAccessHandler is used to determine if the access of a member with account access modifier is valid
	MemberAccountAccessHandler MemberAccountAccessHandlerFunc
	// ValidTopLevelDeclarationsHandler is used to determine the kinds of declarations
	// which are valid at the top-level for a given location
	ValidTopLevelDeclarationsHandler ValidTopLevelDeclarationsHandlerFunc
	BaseTypeActivationHandler        ActivationHandlerFunc
	BaseValueActivationHandler       ActivationHandlerFunc
	// ImportHandler is used to resolve unresolved imports
	ImportHandler ImportHandlerFunc
	// CheckHandler is the function which is used for the checking of a program
	CheckHandler CheckHandlerFunc
	// LocationHandler is used to resolve locations
	LocationHandler LocationHandlerFunc
	// AccessCheckMode is the mode for access control checks.
	// It determines how access modifiers how existing and missing access modifiers are treated
	AccessCheckMode AccessCheckMode
	// ExtendedElaborationEnabled determines if extended elaboration information is generated
	ExtendedElaborationEnabled bool
	// SuggestionsEnabled determines if additional, potentially-computationally intensive,
	// suggested fixes are calculated when producing type errors
	SuggestionsEnabled bool
	// ErrorShortCircuitingEnabled determines if error short-circuiting is enabled.
	// When enabled, the checker will stop running once it encounters an error.
	// When disabled (the default), the checker reports the error then continues checking
	ErrorShortCircuitingEnabled bool
	// PositionInfoEnabled determines if position information is generated.
	// Position info includes origins, occurrences, member accesses, ranges, and function invocations
	PositionInfoEnabled bool
	// AllowNativeDeclarations determines if declarations may be native
	AllowNativeDeclarations bool
	// AllowStaticDeclarations determines if declarations may be static
	AllowStaticDeclarations bool
}

type Conformance 

type Conformance struct {
	InterfaceType        *InterfaceType
	ConformanceChainRoot *InterfaceType
}

type ConformanceError 

type ConformanceError struct {
	CompositeDeclaration        ast.CompositeLikeDeclaration
	CompositeType               *CompositeType
	InterfaceType               *InterfaceType
	NestedInterfaceType         *InterfaceType
	InitializerMismatch         *InitializerMismatch
	MissingMembers              []*Member
	MemberMismatches            []MemberMismatch
	MissingNestedCompositeTypes []*CompositeType
	Pos                         ast.Position
}

func (*ConformanceError) EndPosition 

func (e *ConformanceError) EndPosition(common.MemoryGauge) ast.Position

func (*ConformanceError) Error 

func (e *ConformanceError) Error() string

func (*ConformanceError) ErrorNotes 

func (e *ConformanceError) ErrorNotes() (notes []errors.ErrorNote)

func (*ConformanceError) IsUserError 

func (*ConformanceError) IsUserError()

func (*ConformanceError) SecondaryError 

func (e *ConformanceError) SecondaryError() string

func (*ConformanceError) StartPosition 

func (e *ConformanceError) StartPosition() ast.Position

type ConformingType added in v1.3.0 

type ConformingType interface {
	Type
	EffectiveInterfaceConformanceSet() *InterfaceSet
}

ConformingType is a type that can conform to interfaces

type ConstantSizedArrayLiteralSizeError 

type ConstantSizedArrayLiteralSizeError struct {
	ActualSize   int64
	ExpectedSize int64
	ast.Range
}

func (*ConstantSizedArrayLiteralSizeError) Error 

func (e *ConstantSizedArrayLiteralSizeError) Error() string

func (*ConstantSizedArrayLiteralSizeError) IsUserError 

func (*ConstantSizedArrayLiteralSizeError) IsUserError()

func (*ConstantSizedArrayLiteralSizeError) SecondaryError 

func (e *ConstantSizedArrayLiteralSizeError) SecondaryError() string

type ConstantSizedType 

type ConstantSizedType struct {
	Type Type

	Size int64
	// contains filtered or unexported fields
}

ConstantSizedType is a constant sized array type

func NewConstantSizedType 

func NewConstantSizedType(memoryGauge common.MemoryGauge, typ Type, size int64) *ConstantSizedType

func (*ConstantSizedType) AllowsValueIndexingAssignment 

func (*ConstantSizedType) AllowsValueIndexingAssignment() bool

func (*ConstantSizedType) CheckInstantiated 

func (t *ConstantSizedType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*ConstantSizedType) ContainFieldsOrElements 

func (t *ConstantSizedType) ContainFieldsOrElements() bool

func (*ConstantSizedType) ElementType 

func (t *ConstantSizedType) ElementType(_ bool) Type

func (*ConstantSizedType) Equal 

func (t *ConstantSizedType) Equal(other Type) bool

func (*ConstantSizedType) GetMembers 

func (t *ConstantSizedType) GetMembers() map[string]MemberResolver

func (*ConstantSizedType) ID 

func (t *ConstantSizedType) ID() TypeID

func (*ConstantSizedType) IndexingType 

func (t *ConstantSizedType) IndexingType() Type

func (*ConstantSizedType) IsComparable 

func (t *ConstantSizedType) IsComparable() bool

func (*ConstantSizedType) IsEquatable 

func (t *ConstantSizedType) IsEquatable() bool

func (*ConstantSizedType) IsExportable 

func (t *ConstantSizedType) IsExportable(results map[*Member]bool) bool

func (*ConstantSizedType) IsImportable 

func (t *ConstantSizedType) IsImportable(results map[*Member]bool) bool

func (*ConstantSizedType) IsInvalidType 

func (t *ConstantSizedType) IsInvalidType() bool

func (*ConstantSizedType) IsOrContainsReferenceType 

func (t *ConstantSizedType) IsOrContainsReferenceType() bool

func (*ConstantSizedType) IsPrimitiveType 

func (t *ConstantSizedType) IsPrimitiveType() bool

func (*ConstantSizedType) IsResourceType 

func (t *ConstantSizedType) IsResourceType() bool

func (*ConstantSizedType) IsStorable 

func (t *ConstantSizedType) IsStorable(results map[*Member]bool) bool

func (*ConstantSizedType) IsType 

func (*ConstantSizedType) IsType()

func (*ConstantSizedType) Map 

func (t *ConstantSizedType) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*ConstantSizedType) QualifiedString 

func (t *ConstantSizedType) QualifiedString() string

func (*ConstantSizedType) Resolve 

func (t *ConstantSizedType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*ConstantSizedType) RewriteWithIntersectionTypes 

func (t *ConstantSizedType) RewriteWithIntersectionTypes() (Type, bool)

func (*ConstantSizedType) String 

func (t *ConstantSizedType) String() string

func (*ConstantSizedType) SupportedEntitlements 

func (t *ConstantSizedType) SupportedEntitlements() *EntitlementSet

func (*ConstantSizedType) Tag 

func (t *ConstantSizedType) Tag() TypeTag

func (*ConstantSizedType) TypeAnnotationState 

func (t *ConstantSizedType) TypeAnnotationState() TypeAnnotationState

func (*ConstantSizedType) Unify 

func (t *ConstantSizedType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type ContainedType 

type ContainedType interface {
	Type
	GetContainerType() Type
	SetContainerType(containerType Type)
}

ContainedType is a type which might have a container type

type ContainerKind 

type ContainerKind uint
const (
	ContainerKindUnknown ContainerKind = iota
	ContainerKindInterface
	ContainerKindComposite
)

func (ContainerKind) String 

func (i ContainerKind) String() string

type ContainerType 

type ContainerType interface {
	Type
	IsContainerType() bool
	GetNestedTypes() *StringTypeOrderedMap
}

ContainerType is a type which might have nested types

type ContractValueHandlerFunc 

type ContractValueHandlerFunc func(
	checker *Checker,
	declaration *ast.CompositeDeclaration,
	compositeType *CompositeType,
) ValueDeclaration

type ControlStatementError 

type ControlStatementError struct {
	ControlStatement common.ControlStatement
	ast.Range
}

func (*ControlStatementError) Error 

func (e *ControlStatementError) Error() string

func (*ControlStatementError) IsUserError 

func (*ControlStatementError) IsUserError()

func (*ControlStatementError) SecondaryError 

func (e *ControlStatementError) SecondaryError() string

type CryptoAlgorithm 

type CryptoAlgorithm interface {
	RawValue() uint8
	Name() string
	DocString() string
}

type CyclicConformanceError 

type CyclicConformanceError struct {
	InterfaceType *InterfaceType
	ast.Range
}

CyclicConformanceError

func (CyclicConformanceError) Error 

func (e CyclicConformanceError) Error() string

func (CyclicConformanceError) IsUserError 

func (CyclicConformanceError) IsUserError()

type CyclicEntitlementMappingError 

type CyclicEntitlementMappingError struct {
	Map          *EntitlementMapType
	IncludedType *EntitlementMapType
	ast.Range
}

CyclicEntitlementMappingError

func (*CyclicEntitlementMappingError) Error 

func (e *CyclicEntitlementMappingError) Error() string

func (*CyclicEntitlementMappingError) IsUserError 

func (*CyclicEntitlementMappingError) IsUserError()

type CyclicImportsError 

type CyclicImportsError struct {
	Location common.Location
	ast.Range
}

func (*CyclicImportsError) Error 

func (e *CyclicImportsError) Error() string

func (*CyclicImportsError) IsUserError 

func (*CyclicImportsError) IsUserError()

type DeclarationKindMismatchError 

type DeclarationKindMismatchError struct {
	ExpectedDeclarationKind common.DeclarationKind
	ActualDeclarationKind   common.DeclarationKind
	ast.Range
}

func (*DeclarationKindMismatchError) Error 

func (e *DeclarationKindMismatchError) Error() string

func (*DeclarationKindMismatchError) IsUserError 

func (*DeclarationKindMismatchError) IsUserError()

func (*DeclarationKindMismatchError) SecondaryError 

func (e *DeclarationKindMismatchError) SecondaryError() string

type DefaultDestroyEventInNonResourceError 

type DefaultDestroyEventInNonResourceError struct {
	Kind string
	ast.Range
}

func (*DefaultDestroyEventInNonResourceError) Error 

func (e *DefaultDestroyEventInNonResourceError) Error() string

func (*DefaultDestroyEventInNonResourceError) IsUserError 

func (*DefaultDestroyEventInNonResourceError) IsUserError()

type DefaultDestroyInvalidArgumentError 

type DefaultDestroyInvalidArgumentError struct {
	ast.Range
	Kind DefaultDestroyInvalidArgumentKind
}

func (*DefaultDestroyInvalidArgumentError) Error 

func (e *DefaultDestroyInvalidArgumentError) Error() string

func (*DefaultDestroyInvalidArgumentError) IsUserError 

func (*DefaultDestroyInvalidArgumentError) IsUserError()

func (*DefaultDestroyInvalidArgumentError) SecondaryError 

func (e *DefaultDestroyInvalidArgumentError) SecondaryError() string

type DefaultDestroyInvalidArgumentKind 

type DefaultDestroyInvalidArgumentKind int
const (
	NonDictionaryIndexExpression DefaultDestroyInvalidArgumentKind = iota
	ReferenceTypedMemberAccess
	InvalidIdentifier
	InvalidExpression
)

type DefaultDestroyInvalidParameterError 

type DefaultDestroyInvalidParameterError struct {
	ParamType Type
	ast.Range
}

func (*DefaultDestroyInvalidParameterError) Error 

func (e *DefaultDestroyInvalidParameterError) Error() string

func (*DefaultDestroyInvalidParameterError) IsUserError 

func (*DefaultDestroyInvalidParameterError) IsUserError()

type DictionaryEntryType 

type DictionaryEntryType struct {
	KeyType   Type
	ValueType Type
}

type DictionaryExpressionTypes 

type DictionaryExpressionTypes struct {
	DictionaryType *DictionaryType
	EntryTypes     []DictionaryEntryType
}

type DictionaryType 

type DictionaryType struct {
	KeyType   Type
	ValueType Type
	// contains filtered or unexported fields
}

func NewDictionaryType 

func NewDictionaryType(memoryGauge common.MemoryGauge, keyType, valueType Type) *DictionaryType

func (*DictionaryType) AllowsValueIndexingAssignment 

func (*DictionaryType) AllowsValueIndexingAssignment() bool

func (*DictionaryType) CheckInstantiated 

func (t *DictionaryType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*DictionaryType) ContainFieldsOrElements 

func (*DictionaryType) ContainFieldsOrElements() bool

func (*DictionaryType) ElementType 

func (t *DictionaryType) ElementType(_ bool) Type

func (*DictionaryType) Equal 

func (t *DictionaryType) Equal(other Type) bool

func (*DictionaryType) GetMembers 

func (t *DictionaryType) GetMembers() map[string]MemberResolver

func (*DictionaryType) ID 

func (t *DictionaryType) ID() TypeID

func (*DictionaryType) IndexingType 

func (t *DictionaryType) IndexingType() Type

func (*DictionaryType) IsComparable 

func (*DictionaryType) IsComparable() bool

func (*DictionaryType) IsEquatable 

func (t *DictionaryType) IsEquatable() bool

func (*DictionaryType) IsExportable 

func (t *DictionaryType) IsExportable(results map[*Member]bool) bool

func (*DictionaryType) IsImportable 

func (t *DictionaryType) IsImportable(results map[*Member]bool) bool

func (*DictionaryType) IsInvalidType 

func (t *DictionaryType) IsInvalidType() bool

func (*DictionaryType) IsOrContainsReferenceType 

func (t *DictionaryType) IsOrContainsReferenceType() bool

func (*DictionaryType) IsPrimitiveType 

func (t *DictionaryType) IsPrimitiveType() bool

func (*DictionaryType) IsResourceType 

func (t *DictionaryType) IsResourceType() bool

func (*DictionaryType) IsStorable 

func (t *DictionaryType) IsStorable(results map[*Member]bool) bool

func (*DictionaryType) IsType 

func (*DictionaryType) IsType()

func (*DictionaryType) Map 

func (t *DictionaryType) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*DictionaryType) QualifiedString 

func (t *DictionaryType) QualifiedString() string

func (*DictionaryType) Resolve 

func (t *DictionaryType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*DictionaryType) RewriteWithIntersectionTypes 

func (t *DictionaryType) RewriteWithIntersectionTypes() (Type, bool)

func (*DictionaryType) String 

func (t *DictionaryType) String() string

func (*DictionaryType) SupportedEntitlements 

func (t *DictionaryType) SupportedEntitlements() *EntitlementSet

func (*DictionaryType) Tag 

func (t *DictionaryType) Tag() TypeTag

func (*DictionaryType) TypeAnnotationState 

func (t *DictionaryType) TypeAnnotationState() TypeAnnotationState

func (*DictionaryType) Unify 

func (t *DictionaryType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type DirectEntitlementAnnotationError 

type DirectEntitlementAnnotationError struct {
	ast.Range
}

DirectEntitlementAnnotationError

func (*DirectEntitlementAnnotationError) Error 

func (e *DirectEntitlementAnnotationError) Error() string

func (*DirectEntitlementAnnotationError) IsUserError 

func (*DirectEntitlementAnnotationError) IsUserError()

type DisjunctionOrderedSet 

type DisjunctionOrderedSet = orderedmap.OrderedMap[string, *EntitlementOrderedSet]

DisjunctionOrderedSet is a set of entitlement disjunctions, keyed by disjunctionKey

type DuplicateConformanceError 

type DuplicateConformanceError struct {
	CompositeKindedType CompositeKindedType
	InterfaceType       *InterfaceType
	ast.Range
}

DuplicateConformanceError

TODO: just make this a warning?

func (*DuplicateConformanceError) Error 

func (e *DuplicateConformanceError) Error() string

func (*DuplicateConformanceError) IsUserError 

func (*DuplicateConformanceError) IsUserError()

type DuplicateEntitlementMappingInclusionError 

type DuplicateEntitlementMappingInclusionError struct {
	Map          *EntitlementMapType
	IncludedType *EntitlementMapType
	ast.Range
}

DuplicateEntitlementMappingInclusionError

func (*DuplicateEntitlementMappingInclusionError) Error 

func (e *DuplicateEntitlementMappingInclusionError) Error() string

func (*DuplicateEntitlementMappingInclusionError) IsUserError 

func (*DuplicateEntitlementMappingInclusionError) IsUserError()

type Elaboration 

type Elaboration struct {
	TransactionTypes []*TransactionType

	// IsRecovered is true if the program was recovered (see runtime.Interface.RecoverProgram)
	IsRecovered bool
	// contains filtered or unexported fields
}

func NewElaboration 

func NewElaboration(gauge common.MemoryGauge) *Elaboration

func (*Elaboration) AllExpressionTypes 

func (e *Elaboration) AllExpressionTypes() map[ast.Expression]ExpressionTypes

func (*Elaboration) AllStaticCastTypes 

func (e *Elaboration) AllStaticCastTypes() map[*ast.CastingExpression]CastTypes

func (*Elaboration) ArrayExpressionTypes 

func (e *Elaboration) ArrayExpressionTypes(expression *ast.ArrayExpression) (types ArrayExpressionTypes)

func (*Elaboration) AssignmentStatementTypes 

func (e *Elaboration) AssignmentStatementTypes(assignment *ast.AssignmentStatement) (types AssignmentStatementTypes)

func (*Elaboration) AttachTypes 

func (e *Elaboration) AttachTypes(
	expr *ast.AttachExpression,
) (
	ty *CompositeType,
)

func (*Elaboration) AttachmentAccessTypes 

func (e *Elaboration) AttachmentAccessTypes(
	expression *ast.IndexExpression,
) (
	ty Type, ok bool,
)

func (*Elaboration) AttachmentRemoveTypes 

func (e *Elaboration) AttachmentRemoveTypes(
	stmt *ast.RemoveStatement,
) (
	ty Type,
)

func (*Elaboration) BinaryExpressionTypes 

func (e *Elaboration) BinaryExpressionTypes(expression *ast.BinaryExpression) (types BinaryExpressionTypes)

func (*Elaboration) CastingExpressionTypes 

func (e *Elaboration) CastingExpressionTypes(expression *ast.CastingExpression) (types CastingExpressionTypes)

func (*Elaboration) CompositeDeclarationType 

func (e *Elaboration) CompositeDeclarationType(declaration ast.CompositeLikeDeclaration) *CompositeType

func (*Elaboration) CompositeNestedDeclarations 

func (e *Elaboration) CompositeNestedDeclarations(declaration ast.CompositeLikeDeclaration) map[string]ast.Declaration

func (*Elaboration) CompositeType 

func (e *Elaboration) CompositeType(typeID common.TypeID) *CompositeType

func (*Elaboration) CompositeTypeDeclaration 

func (e *Elaboration) CompositeTypeDeclaration(compositeType *CompositeType) (decl ast.CompositeLikeDeclaration, ok bool)

func (*Elaboration) ConstructorFunctionType 

func (e *Elaboration) ConstructorFunctionType(initializer *ast.SpecialFunctionDeclaration) *FunctionType

func (*Elaboration) DefaultDestroyDeclaration 

func (e *Elaboration) DefaultDestroyDeclaration(declaration ast.Declaration) ast.CompositeLikeDeclaration

func (*Elaboration) DictionaryExpressionTypes 

func (e *Elaboration) DictionaryExpressionTypes(
	expression *ast.DictionaryExpression,
) (types DictionaryExpressionTypes)

func (*Elaboration) EmitStatementEventType 

func (e *Elaboration) EmitStatementEventType(statement *ast.EmitStatement) *CompositeType

func (*Elaboration) EntitlementDeclarationType 

func (e *Elaboration) EntitlementDeclarationType(declaration *ast.EntitlementDeclaration) *EntitlementType

func (*Elaboration) EntitlementMapDeclarationType 

func (e *Elaboration) EntitlementMapDeclarationType(declaration *ast.EntitlementMappingDeclaration) *EntitlementMapType

func (*Elaboration) EntitlementMapType 

func (e *Elaboration) EntitlementMapType(typeID common.TypeID) *EntitlementMapType

func (*Elaboration) EntitlementMapTypeDeclaration 

func (e *Elaboration) EntitlementMapTypeDeclaration(entitlementMapType *EntitlementMapType) *ast.EntitlementMappingDeclaration

func (*Elaboration) EntitlementType 

func (e *Elaboration) EntitlementType(typeID common.TypeID) *EntitlementType

func (*Elaboration) EntitlementTypeDeclaration 

func (e *Elaboration) EntitlementTypeDeclaration(entitlementType *EntitlementType) *ast.EntitlementDeclaration

func (*Elaboration) ExpressionTypes 

func (e *Elaboration) ExpressionTypes(expression ast.Expression) ExpressionTypes

func (*Elaboration) FixedPointExpression 

func (e *Elaboration) FixedPointExpression(expression *ast.FixedPointExpression) Type

func (*Elaboration) ForEachGlobalType 

func (e *Elaboration) ForEachGlobalType(f func(name string, variable *Variable))

func (*Elaboration) ForEachGlobalValue 

func (e *Elaboration) ForEachGlobalValue(f func(name string, variable *Variable))

func (*Elaboration) ForStatementType 

func (e *Elaboration) ForStatementType(statement *ast.ForStatement) (types ForStatementTypes)

func (*Elaboration) ForceExpressionType 

func (e *Elaboration) ForceExpressionType(expression *ast.ForceExpression) Type

func (*Elaboration) FunctionDeclarationFunctionType 

func (e *Elaboration) FunctionDeclarationFunctionType(declaration *ast.FunctionDeclaration) *FunctionType

func (*Elaboration) FunctionEntryPointType 

func (e *Elaboration) FunctionEntryPointType() (*FunctionType, error)

FunctionEntryPointType returns the type of the entry point function declaration, if any.

Returns an error if no valid entry point function declaration exists.

func (*Elaboration) FunctionExpressionFunctionType 

func (e *Elaboration) FunctionExpressionFunctionType(expression *ast.FunctionExpression) *FunctionType

func (*Elaboration) GetGlobalType 

func (e *Elaboration) GetGlobalType(name string) (*Variable, bool)

func (*Elaboration) GetGlobalValue 

func (e *Elaboration) GetGlobalValue(name string) (*Variable, bool)

func (*Elaboration) GetSemanticAccess 

func (e *Elaboration) GetSemanticAccess(access ast.Access) (semaAccess Access, present bool)

func (*Elaboration) IdentifierInInvocationType 

func (e *Elaboration) IdentifierInInvocationType(expression *ast.IdentifierExpression) Type

func (*Elaboration) ImportDeclarationsResolvedLocations 

func (e *Elaboration) ImportDeclarationsResolvedLocations(declaration *ast.ImportDeclaration) []ResolvedLocation

func (*Elaboration) IndexExpressionTypes 

func (e *Elaboration) IndexExpressionTypes(expression *ast.IndexExpression) (types IndexExpressionTypes, contains bool)

func (*Elaboration) IntegerExpressionType 

func (e *Elaboration) IntegerExpressionType(expression *ast.IntegerExpression) Type

func (*Elaboration) InterfaceDeclarationType 

func (e *Elaboration) InterfaceDeclarationType(declaration *ast.InterfaceDeclaration) *InterfaceType

func (*Elaboration) InterfaceNestedDeclarations 

func (e *Elaboration) InterfaceNestedDeclarations(declaration *ast.InterfaceDeclaration) map[string]ast.Declaration

func (*Elaboration) InterfaceType 

func (e *Elaboration) InterfaceType(typeID common.TypeID) *InterfaceType

func (*Elaboration) InterfaceTypeDeclaration 

func (e *Elaboration) InterfaceTypeDeclaration(interfaceType *InterfaceType) *ast.InterfaceDeclaration

func (*Elaboration) InvocationExpressionTypes 

func (e *Elaboration) InvocationExpressionTypes(
	expression *ast.InvocationExpression,
) (types InvocationExpressionTypes)

func (*Elaboration) IsChecking 

func (e *Elaboration) IsChecking() bool

func (*Elaboration) IsNestedResourceMoveExpression 

func (e *Elaboration) IsNestedResourceMoveExpression(expression ast.Expression) bool

func (*Elaboration) MemberExpressionExpectedType 

func (e *Elaboration) MemberExpressionExpectedType(expression *ast.MemberExpression) Type

func (*Elaboration) MemberExpressionMemberAccessInfo 

func (e *Elaboration) MemberExpressionMemberAccessInfo(expression *ast.MemberExpression) (memberInfo MemberAccessInfo, ok bool)

func (*Elaboration) NumberConversionArgumentTypes 

func (e *Elaboration) NumberConversionArgumentTypes(
	expression ast.Expression,
) (
	types NumberConversionArgumentTypes,
)

func (*Elaboration) PostConditionsRewrite 

func (e *Elaboration) PostConditionsRewrite(conditions *ast.Conditions) (rewrite PostConditionsRewrite)

func (*Elaboration) ReferenceExpressionBorrowType 

func (e *Elaboration) ReferenceExpressionBorrowType(expression *ast.ReferenceExpression) Type

func (*Elaboration) ReturnStatementTypes 

func (e *Elaboration) ReturnStatementTypes(statement *ast.ReturnStatement) (types ReturnStatementTypes)

func (*Elaboration) RuntimeCastTypes 

func (e *Elaboration) RuntimeCastTypes(expression *ast.CastingExpression) (types RuntimeCastTypes)

func (*Elaboration) SetArrayExpressionTypes 

func (e *Elaboration) SetArrayExpressionTypes(expression *ast.ArrayExpression, types ArrayExpressionTypes)

func (*Elaboration) SetAssignmentStatementTypes 

func (e *Elaboration) SetAssignmentStatementTypes(
	assignment *ast.AssignmentStatement,
	types AssignmentStatementTypes,
)

func (*Elaboration) SetAttachTypes 

func (e *Elaboration) SetAttachTypes(
	expr *ast.AttachExpression,
	ty *CompositeType,
)

func (*Elaboration) SetAttachmentAccessTypes 

func (e *Elaboration) SetAttachmentAccessTypes(
	expression *ast.IndexExpression,
	ty Type,
)

func (*Elaboration) SetAttachmentRemoveTypes 

func (e *Elaboration) SetAttachmentRemoveTypes(
	stmt *ast.RemoveStatement,
	ty Type,
)

func (*Elaboration) SetBinaryExpressionTypes 

func (e *Elaboration) SetBinaryExpressionTypes(expression *ast.BinaryExpression, types BinaryExpressionTypes)

func (*Elaboration) SetCastingExpressionTypes 

func (e *Elaboration) SetCastingExpressionTypes(
	expression *ast.CastingExpression,
	types CastingExpressionTypes,
)

func (*Elaboration) SetCompositeDeclarationType 

func (e *Elaboration) SetCompositeDeclarationType(
	declaration ast.CompositeLikeDeclaration,
	compositeType *CompositeType,
)

func (*Elaboration) SetCompositeNestedDeclarations 

func (e *Elaboration) SetCompositeNestedDeclarations(
	declaration ast.CompositeLikeDeclaration,
	nestedDeclaration map[string]ast.Declaration,
)

func (*Elaboration) SetCompositeType 

func (e *Elaboration) SetCompositeType(typeID TypeID, ty *CompositeType)

func (*Elaboration) SetCompositeTypeDeclaration 

func (e *Elaboration) SetCompositeTypeDeclaration(
	compositeType *CompositeType,
	declaration ast.CompositeLikeDeclaration,
)

func (*Elaboration) SetConstructorFunctionType 

func (e *Elaboration) SetConstructorFunctionType(
	initializer *ast.SpecialFunctionDeclaration,
	functionType *FunctionType,
)

func (*Elaboration) SetDefaultDestroyDeclaration 

func (e *Elaboration) SetDefaultDestroyDeclaration(
	declaration ast.Declaration,
	eventDeclaration ast.CompositeLikeDeclaration,
)

func (*Elaboration) SetDictionaryExpressionTypes 

func (e *Elaboration) SetDictionaryExpressionTypes(
	expression *ast.DictionaryExpression,
	types DictionaryExpressionTypes,
)

func (*Elaboration) SetEmitStatementEventType 

func (e *Elaboration) SetEmitStatementEventType(statement *ast.EmitStatement, compositeType *CompositeType)

func (*Elaboration) SetEntitlementDeclarationWithType 

func (e *Elaboration) SetEntitlementDeclarationWithType(
	declaration *ast.EntitlementDeclaration,
	entitlementType *EntitlementType,
)

func (*Elaboration) SetEntitlementMapDeclarationWithType 

func (e *Elaboration) SetEntitlementMapDeclarationWithType(
	declaration *ast.EntitlementMappingDeclaration,
	entitlementMapType *EntitlementMapType,
)

func (*Elaboration) SetEntitlementMapType 

func (e *Elaboration) SetEntitlementMapType(typeID TypeID, ty *EntitlementMapType)

func (*Elaboration) SetEntitlementType 

func (e *Elaboration) SetEntitlementType(typeID TypeID, ty *EntitlementType)

func (*Elaboration) SetExpressionTypes 

func (e *Elaboration) SetExpressionTypes(expression ast.Expression, types ExpressionTypes)

func (*Elaboration) SetFixedPointExpression 

func (e *Elaboration) SetFixedPointExpression(expression *ast.FixedPointExpression, ty Type)

func (*Elaboration) SetForStatementType 

func (e *Elaboration) SetForStatementType(statement *ast.ForStatement, types ForStatementTypes)

func (*Elaboration) SetForceExpressionType 

func (e *Elaboration) SetForceExpressionType(expression *ast.ForceExpression, ty Type)

func (*Elaboration) SetFunctionDeclarationFunctionType 

func (e *Elaboration) SetFunctionDeclarationFunctionType(
	declaration *ast.FunctionDeclaration,
	functionType *FunctionType,
)

func (*Elaboration) SetFunctionExpressionFunctionType 

func (e *Elaboration) SetFunctionExpressionFunctionType(
	expression *ast.FunctionExpression,
	functionType *FunctionType,
)

func (*Elaboration) SetGlobalType 

func (e *Elaboration) SetGlobalType(name string, variable *Variable)

func (*Elaboration) SetGlobalValue 

func (e *Elaboration) SetGlobalValue(name string, variable *Variable)

func (*Elaboration) SetIdentifierInInvocationType 

func (e *Elaboration) SetIdentifierInInvocationType(expression *ast.IdentifierExpression, valueType Type)

func (*Elaboration) SetImportDeclarationsResolvedLocations 

func (e *Elaboration) SetImportDeclarationsResolvedLocations(
	declaration *ast.ImportDeclaration,
	locations []ResolvedLocation,
)

func (*Elaboration) SetIndexExpressionTypes 

func (e *Elaboration) SetIndexExpressionTypes(expression *ast.IndexExpression, types IndexExpressionTypes)

func (*Elaboration) SetIntegerExpressionType 

func (e *Elaboration) SetIntegerExpressionType(expression *ast.IntegerExpression, actualType Type)

func (*Elaboration) SetInterfaceDeclarationWithType 

func (e *Elaboration) SetInterfaceDeclarationWithType(
	declaration *ast.InterfaceDeclaration,
	interfaceType *InterfaceType,
)

func (*Elaboration) SetInterfaceNestedDeclarations 

func (e *Elaboration) SetInterfaceNestedDeclarations(
	declaration *ast.InterfaceDeclaration,
	nestedDeclaration map[string]ast.Declaration,
)

func (*Elaboration) SetInterfaceType 

func (e *Elaboration) SetInterfaceType(typeID TypeID, ty *InterfaceType)

func (*Elaboration) SetInvocationExpressionTypes 

func (e *Elaboration) SetInvocationExpressionTypes(
	expression *ast.InvocationExpression,
	types InvocationExpressionTypes,
)

func (*Elaboration) SetIsNestedResourceMoveExpression 

func (e *Elaboration) SetIsNestedResourceMoveExpression(expression ast.Expression)

func (*Elaboration) SetMemberExpressionExpectedType 

func (e *Elaboration) SetMemberExpressionExpectedType(expression *ast.MemberExpression, expectedType Type)

func (*Elaboration) SetMemberExpressionMemberAccessInfo 

func (e *Elaboration) SetMemberExpressionMemberAccessInfo(expression *ast.MemberExpression, memberAccessInfo MemberAccessInfo)

func (*Elaboration) SetNumberConversionArgumentTypes 

func (e *Elaboration) SetNumberConversionArgumentTypes(
	expression ast.Expression,
	types NumberConversionArgumentTypes,
)

func (*Elaboration) SetPostConditionsRewrite 

func (e *Elaboration) SetPostConditionsRewrite(conditions *ast.Conditions, rewrite PostConditionsRewrite)

func (*Elaboration) SetReferenceExpressionBorrowType 

func (e *Elaboration) SetReferenceExpressionBorrowType(expression *ast.ReferenceExpression, ty Type)

func (*Elaboration) SetReturnStatementTypes 

func (e *Elaboration) SetReturnStatementTypes(statement *ast.ReturnStatement, types ReturnStatementTypes)

func (*Elaboration) SetRuntimeCastTypes 

func (e *Elaboration) SetRuntimeCastTypes(expression *ast.CastingExpression, types RuntimeCastTypes)

func (*Elaboration) SetSemanticAccess 

func (e *Elaboration) SetSemanticAccess(access ast.Access, semanticAccess Access)

func (*Elaboration) SetStaticCastTypes 

func (e *Elaboration) SetStaticCastTypes(expression *ast.CastingExpression, types CastTypes)

func (*Elaboration) SetStringExpressionType 

func (e *Elaboration) SetStringExpressionType(expression *ast.StringExpression, ty Type)

func (*Elaboration) SetSwapStatementTypes 

func (e *Elaboration) SetSwapStatementTypes(statement *ast.SwapStatement, types SwapStatementTypes)

func (*Elaboration) SetTransactionDeclarationType 

func (e *Elaboration) SetTransactionDeclarationType(declaration *ast.TransactionDeclaration, ty *TransactionType)

func (*Elaboration) SetVariableDeclarationTypes 

func (e *Elaboration) SetVariableDeclarationTypes(
	declaration *ast.VariableDeclaration,
	types VariableDeclarationTypes,
)

func (*Elaboration) StaticCastTypes 

func (e *Elaboration) StaticCastTypes(expression *ast.CastingExpression) (types CastTypes)

func (*Elaboration) StringExpressionType 

func (e *Elaboration) StringExpressionType(expression *ast.StringExpression) Type

func (*Elaboration) SwapStatementTypes 

func (e *Elaboration) SwapStatementTypes(statement *ast.SwapStatement) (types SwapStatementTypes)

func (*Elaboration) TransactionDeclarationType 

func (e *Elaboration) TransactionDeclarationType(declaration *ast.TransactionDeclaration) *TransactionType

func (*Elaboration) VariableDeclarationTypes 

func (e *Elaboration) VariableDeclarationTypes(declaration *ast.VariableDeclaration) (types VariableDeclarationTypes)

func (*Elaboration) VariableDeclarationTypesCount 

func (e *Elaboration) VariableDeclarationTypesCount() int

type ElaborationImport 

type ElaborationImport struct {
	Elaboration *Elaboration
}

ElaborationImport

func (ElaborationImport) AllTypeElements 

func (i ElaborationImport) AllTypeElements() *StringImportElementOrderedMap

func (ElaborationImport) AllValueElements 

func (i ElaborationImport) AllValueElements() *StringImportElementOrderedMap

func (ElaborationImport) IsChecking 

func (i ElaborationImport) IsChecking() bool

type EmitDefaultDestroyEventError 

type EmitDefaultDestroyEventError struct {
	ast.Range
}

func (*EmitDefaultDestroyEventError) Error 

func (e *EmitDefaultDestroyEventError) Error() string

func (*EmitDefaultDestroyEventError) IsUserError 

func (*EmitDefaultDestroyEventError) IsUserError()

type EmitImportedEventError 

type EmitImportedEventError struct {
	Type Type
	ast.Range
}

func (*EmitImportedEventError) Error 

func (e *EmitImportedEventError) Error() string

func (*EmitImportedEventError) IsUserError 

func (*EmitImportedEventError) IsUserError()

type EmitNonEventError 

type EmitNonEventError struct {
	Type Type
	ast.Range
}

func (*EmitNonEventError) Error 

func (e *EmitNonEventError) Error() string

func (*EmitNonEventError) IsUserError 

func (*EmitNonEventError) IsUserError()

type EndPositionGetter 

type EndPositionGetter func(common.MemoryGauge) ast.Position

type EntitlementMapAccess 

type EntitlementMapAccess struct {
	Type *EntitlementMapType
	// contains filtered or unexported fields
}

func NewEntitlementMapAccess 

func NewEntitlementMapAccess(mapType *EntitlementMapType) *EntitlementMapAccess

func (*EntitlementMapAccess) Codomain 

func (e *EntitlementMapAccess) Codomain() Access

func (*EntitlementMapAccess) Domain 

func (e *EntitlementMapAccess) Domain() EntitlementSetAccess

func (*EntitlementMapAccess) Equal 

func (e *EntitlementMapAccess) Equal(other Access) bool

func (*EntitlementMapAccess) ID 

func (e *EntitlementMapAccess) ID() TypeID

func (*EntitlementMapAccess) Image 

func (e *EntitlementMapAccess) Image(inputs Access, astRange func() ast.Range) (Access, error)

Image applies all the entitlements in the `argumentAccess` to the function defined by the map in `e`, producing a new entitlement set of the image of the arguments.

func (*EntitlementMapAccess) IsPrimitiveAccess 

func (*EntitlementMapAccess) IsPrimitiveAccess() bool

func (*EntitlementMapAccess) PermitsAccess 

func (e *EntitlementMapAccess) PermitsAccess(other Access) bool

func (*EntitlementMapAccess) QualifiedKeyword 

func (e *EntitlementMapAccess) QualifiedKeyword() string

func (*EntitlementMapAccess) QualifiedString 

func (e *EntitlementMapAccess) QualifiedString() string

func (*EntitlementMapAccess) String 

func (e *EntitlementMapAccess) String() string

type EntitlementMapType 

type EntitlementMapType struct {
	Location common.Location

	Identifier string
	Relations  []EntitlementRelation

	// Whether this map type includes the special identity relation,
	// which maps every input to itself. The `Identity` mapping itself
	// is defined as the empty map type that includes the identity relation
	IncludesIdentity bool
	// contains filtered or unexported fields
}

func NewEntitlementMapType 

func NewEntitlementMapType(
	memoryGauge common.MemoryGauge,
	location common.Location,
	identifier string,
) *EntitlementMapType

func (*EntitlementMapType) CheckInstantiated 

func (t *EntitlementMapType) CheckInstantiated(_ ast.HasPosition, _ common.MemoryGauge, _ func(err error))

func (*EntitlementMapType) ContainFieldsOrElements 

func (*EntitlementMapType) ContainFieldsOrElements() bool

func (*EntitlementMapType) Equal 

func (t *EntitlementMapType) Equal(other Type) bool

func (*EntitlementMapType) GetContainerType 

func (t *EntitlementMapType) GetContainerType() Type

func (*EntitlementMapType) GetLocation 

func (t *EntitlementMapType) GetLocation() common.Location

func (*EntitlementMapType) GetMembers 

func (t *EntitlementMapType) GetMembers() map[string]MemberResolver

func (*EntitlementMapType) ID 

func (t *EntitlementMapType) ID() TypeID

func (*EntitlementMapType) IsComparable 

func (*EntitlementMapType) IsComparable() bool

func (*EntitlementMapType) IsEquatable 

func (*EntitlementMapType) IsEquatable() bool

func (*EntitlementMapType) IsExportable 

func (*EntitlementMapType) IsExportable(_ map[*Member]bool) bool

func (*EntitlementMapType) IsImportable 

func (*EntitlementMapType) IsImportable(_ map[*Member]bool) bool

func (*EntitlementMapType) IsInvalidType 

func (*EntitlementMapType) IsInvalidType() bool

func (*EntitlementMapType) IsOrContainsReferenceType 

func (*EntitlementMapType) IsOrContainsReferenceType() bool

func (*EntitlementMapType) IsPrimitiveType 

func (*EntitlementMapType) IsPrimitiveType() bool

func (*EntitlementMapType) IsResourceType 

func (*EntitlementMapType) IsResourceType() bool

func (*EntitlementMapType) IsStorable 

func (*EntitlementMapType) IsStorable(_ map[*Member]bool) bool

func (*EntitlementMapType) IsType 

func (*EntitlementMapType) IsType()

func (*EntitlementMapType) Map 

func (t *EntitlementMapType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*EntitlementMapType) QualifiedIdentifier 

func (t *EntitlementMapType) QualifiedIdentifier() string

func (*EntitlementMapType) QualifiedString 

func (t *EntitlementMapType) QualifiedString() string

func (*EntitlementMapType) Resolve 

func (t *EntitlementMapType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*EntitlementMapType) RewriteWithIntersectionTypes 

func (t *EntitlementMapType) RewriteWithIntersectionTypes() (Type, bool)

func (*EntitlementMapType) SetContainerType 

func (t *EntitlementMapType) SetContainerType(containerType Type)

func (*EntitlementMapType) String 

func (t *EntitlementMapType) String() string

func (*EntitlementMapType) Tag 

func (t *EntitlementMapType) Tag() TypeTag

func (*EntitlementMapType) TypeAnnotationState 

func (*EntitlementMapType) TypeAnnotationState() TypeAnnotationState

func (*EntitlementMapType) Unify 

func (*EntitlementMapType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type EntitlementOrderedSet 

type EntitlementOrderedSet = orderedmap.OrderedMap[*EntitlementType, struct{}]

type EntitlementRelation 

type EntitlementRelation struct {
	Input  *EntitlementType
	Output *EntitlementType
}

func NewEntitlementRelation 

func NewEntitlementRelation(
	memoryGauge common.MemoryGauge,
	input *EntitlementType,
	output *EntitlementType,
) EntitlementRelation

type EntitlementSet 

type EntitlementSet struct {
	// Entitlements is a set of entitlements
	Entitlements *EntitlementOrderedSet
	// Disjunctions is a set of entitlement disjunctions, keyed by disjunctionKey
	Disjunctions *DisjunctionOrderedSet
	// contains filtered or unexported fields
}

EntitlementSet is a set (conjunction) of entitlements and entitlement disjunctions. e.g. {entitlements: A, B; disjunctions: (C ∨ D), (E ∨ F)} This is distinct from an EntitlementSetAccess in Cadence, which is a program-level (and possibly non-minimal) approximation of this abstract set

func (*EntitlementSet) Access 

func (s *EntitlementSet) Access() Access

Access returns the access represented by the entitlement set. The set is minimized before the access is computed. Note that this function may over-approximate the permissions required to represent this set of entitlements as an access modifier that Cadence can use, e.g. `(A ∨ B) ∧ C` cannot be represented in Cadence and will the produce an over-approximation of `(A, B, C)`

func (*EntitlementSet) Add 

func (s *EntitlementSet) Add(entitlementType *EntitlementType)

Add adds an entitlement to the set.

NOTE: The resulting set is potentially not minimal: If the set contains a disjunction that contains the entitlement, then the disjunction is NOT discarded. Call Minimize to obtain a minimal set.

func (*EntitlementSet) AddDisjunction 

func (s *EntitlementSet) AddDisjunction(disjunction *EntitlementOrderedSet)

AddDisjunction adds an entitlement disjunction to the set. If the set already contains an entitlement of the given disjunction, then the disjunction is discarded.

func (*EntitlementSet) IsMinimallyRepresentable 

func (s *EntitlementSet) IsMinimallyRepresentable() bool

Returns whether this entitlement set is minimally representable in Cadence.

If true, this set can be exactly represented as a non-nested logical formula: i.e. either a single conjunction or a single disjunction If false, this set cannot be represented without nesting connective operators, and thus must be over-approximated when being represented in Cadence. As Cadence does not support nesting disjunctions and conjunctions in the same entitlement set, this function returns false when s.Entitlements and s.Disjunctions are both non-empty, or when s.Disjunctions has more than one element

func (*EntitlementSet) Merge 

func (s *EntitlementSet) Merge(other *EntitlementSet)

Merge merges the other entitlement set into this set. The result is the union of the entitlements and disjunctions of both sets.

The result is not necessarily minimal: For example, if s contains a disjunction d, and other contains an entitlement e that is part of d, then the result will still contain d. See Add. Call Minimize to obtain a minimal set.

func (*EntitlementSet) Minimize 

func (s *EntitlementSet) Minimize()

Minimize minimizes the entitlement set. It removes disjunctions that contain entitlements which are also in the entitlement set

type EntitlementSetAccess 

type EntitlementSetAccess struct {
	Entitlements *EntitlementOrderedSet
	SetKind      EntitlementSetKind
	// contains filtered or unexported fields
}

func NewEntitlementSetAccess 

func NewEntitlementSetAccess(
	entitlements []*EntitlementType,
	setKind EntitlementSetKind,
) EntitlementSetAccess

func (EntitlementSetAccess) Equal 

func (e EntitlementSetAccess) Equal(other Access) bool

func (EntitlementSetAccess) ID 

func (e EntitlementSetAccess) ID() TypeID

func (EntitlementSetAccess) IsPrimitiveAccess 

func (EntitlementSetAccess) IsPrimitiveAccess() bool

func (EntitlementSetAccess) PermitsAccess 

func (e EntitlementSetAccess) PermitsAccess(other Access) bool

func (EntitlementSetAccess) QualifiedKeyword 

func (e EntitlementSetAccess) QualifiedKeyword() string

func (EntitlementSetAccess) QualifiedString 

func (e EntitlementSetAccess) QualifiedString() string

func (EntitlementSetAccess) String 

func (e EntitlementSetAccess) String() string

type EntitlementSetKind 

type EntitlementSetKind uint8
const (
	Conjunction EntitlementSetKind = iota
	Disjunction
)

type EntitlementSupportingType 

type EntitlementSupportingType interface {
	Type
	SupportedEntitlements() *EntitlementSet
}

entitlement supporting types

type EntitlementType 

type EntitlementType struct {
	Location common.Location

	Identifier string
	// contains filtered or unexported fields
}

func NewEntitlementType 

func NewEntitlementType(memoryGauge common.MemoryGauge, location common.Location, identifier string) *EntitlementType

func (*EntitlementType) CheckInstantiated 

func (t *EntitlementType) CheckInstantiated(_ ast.HasPosition, _ common.MemoryGauge, _ func(err error))

func (*EntitlementType) ContainFieldsOrElements 

func (*EntitlementType) ContainFieldsOrElements() bool

func (*EntitlementType) Equal 

func (t *EntitlementType) Equal(other Type) bool

func (*EntitlementType) GetContainerType 

func (t *EntitlementType) GetContainerType() Type

func (*EntitlementType) GetLocation 

func (t *EntitlementType) GetLocation() common.Location

func (*EntitlementType) GetMembers 

func (t *EntitlementType) GetMembers() map[string]MemberResolver

func (*EntitlementType) ID 

func (t *EntitlementType) ID() TypeID

func (*EntitlementType) IsComparable 

func (*EntitlementType) IsComparable() bool

func (*EntitlementType) IsEquatable 

func (*EntitlementType) IsEquatable() bool

func (*EntitlementType) IsExportable 

func (*EntitlementType) IsExportable(_ map[*Member]bool) bool

func (*EntitlementType) IsImportable 

func (*EntitlementType) IsImportable(_ map[*Member]bool) bool

func (*EntitlementType) IsInvalidType 

func (t *EntitlementType) IsInvalidType() bool

func (*EntitlementType) IsOrContainsReferenceType 

func (*EntitlementType) IsOrContainsReferenceType() bool

func (*EntitlementType) IsPrimitiveType 

func (*EntitlementType) IsPrimitiveType() bool

func (*EntitlementType) IsResourceType 

func (*EntitlementType) IsResourceType() bool

func (*EntitlementType) IsStorable 

func (*EntitlementType) IsStorable(_ map[*Member]bool) bool

func (*EntitlementType) IsType 

func (*EntitlementType) IsType()

func (*EntitlementType) Map 

func (t *EntitlementType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*EntitlementType) QualifiedIdentifier 

func (t *EntitlementType) QualifiedIdentifier() string

func (*EntitlementType) QualifiedString 

func (t *EntitlementType) QualifiedString() string

func (*EntitlementType) Resolve 

func (t *EntitlementType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*EntitlementType) RewriteWithIntersectionTypes 

func (t *EntitlementType) RewriteWithIntersectionTypes() (Type, bool)

func (*EntitlementType) SetContainerType 

func (t *EntitlementType) SetContainerType(containerType Type)

func (*EntitlementType) String 

func (t *EntitlementType) String() string

func (*EntitlementType) Tag 

func (t *EntitlementType) Tag() TypeTag

func (*EntitlementType) TypeAnnotationState 

func (*EntitlementType) TypeAnnotationState() TypeAnnotationState

func (*EntitlementType) Unify 

func (*EntitlementType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type EnumInfo 

type EnumInfo struct {
	RawType Type
	Cases   []string
}

type ExcessiveArgumentsError 

type ExcessiveArgumentsError struct {
	MaxCount    int
	ActualCount int
	ast.Range
}

func (*ExcessiveArgumentsError) Error 

func (e *ExcessiveArgumentsError) Error() string

func (*ExcessiveArgumentsError) IsUserError 

func (*ExcessiveArgumentsError) IsUserError()

func (*ExcessiveArgumentsError) SecondaryError 

func (e *ExcessiveArgumentsError) SecondaryError() string

type ExpressionTypes 

type ExpressionTypes struct {
	ActualType   Type
	ExpectedType Type
}

type FieldReinitializationError 

type FieldReinitializationError struct {
	Name string
	ast.Range
}

FieldReinitializationError

func (*FieldReinitializationError) Error 

func (e *FieldReinitializationError) Error() string

func (*FieldReinitializationError) IsUserError 

func (*FieldReinitializationError) IsUserError()

type FieldTypeNotStorableError 

type FieldTypeNotStorableError struct {
	Type Type
	Name string
	Pos  ast.Position
}

func (*FieldTypeNotStorableError) EndPosition 

func (e *FieldTypeNotStorableError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*FieldTypeNotStorableError) Error 

func (e *FieldTypeNotStorableError) Error() string

func (*FieldTypeNotStorableError) IsUserError 

func (*FieldTypeNotStorableError) IsUserError()

func (*FieldTypeNotStorableError) SecondaryError 

func (e *FieldTypeNotStorableError) SecondaryError() string

func (*FieldTypeNotStorableError) StartPosition 

func (e *FieldTypeNotStorableError) StartPosition() ast.Position

type FieldUninitializedError 

type FieldUninitializedError struct {
	ContainerType Type
	Name          string
	Pos           ast.Position
}

FieldUninitializedError

func (*FieldUninitializedError) EndPosition 

func (e *FieldUninitializedError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*FieldUninitializedError) Error 

func (e *FieldUninitializedError) Error() string

func (*FieldUninitializedError) IsUserError 

func (*FieldUninitializedError) IsUserError()

func (*FieldUninitializedError) SecondaryError 

func (e *FieldUninitializedError) SecondaryError() string

func (*FieldUninitializedError) StartPosition 

func (e *FieldUninitializedError) StartPosition() ast.Position

type FixedPointNumericType 

type FixedPointNumericType struct {
	// contains filtered or unexported fields
}

FixedPointNumericType represents all the types in the fixed-point range.

func NewFixedPointNumericType 

func NewFixedPointNumericType(typeName string) *FixedPointNumericType

func (*FixedPointNumericType) AsSuperType 

func (t *FixedPointNumericType) AsSuperType() *FixedPointNumericType

func (*FixedPointNumericType) CheckInstantiated 

func (*FixedPointNumericType) CheckInstantiated(_ ast.HasPosition, _ common.MemoryGauge, _ func(err error))

func (*FixedPointNumericType) ContainFieldsOrElements 

func (t *FixedPointNumericType) ContainFieldsOrElements() bool

func (*FixedPointNumericType) Equal 

func (t *FixedPointNumericType) Equal(other Type) bool

func (*FixedPointNumericType) GetMembers 

func (t *FixedPointNumericType) GetMembers() map[string]MemberResolver

func (*FixedPointNumericType) ID 

func (t *FixedPointNumericType) ID() TypeID

func (*FixedPointNumericType) IsComparable 

func (t *FixedPointNumericType) IsComparable() bool

func (*FixedPointNumericType) IsEquatable 

func (*FixedPointNumericType) IsEquatable() bool

func (*FixedPointNumericType) IsExportable 

func (*FixedPointNumericType) IsExportable(_ map[*Member]bool) bool

func (*FixedPointNumericType) IsImportable 

func (t *FixedPointNumericType) IsImportable(_ map[*Member]bool) bool

func (*FixedPointNumericType) IsInvalidType 

func (*FixedPointNumericType) IsInvalidType() bool

func (*FixedPointNumericType) IsOrContainsReferenceType 

func (*FixedPointNumericType) IsOrContainsReferenceType() bool

func (*FixedPointNumericType) IsPrimitiveType 

func (*FixedPointNumericType) IsPrimitiveType() bool

func (*FixedPointNumericType) IsResourceType 

func (*FixedPointNumericType) IsResourceType() bool

func (*FixedPointNumericType) IsStorable 

func (*FixedPointNumericType) IsStorable(_ map[*Member]bool) bool

func (*FixedPointNumericType) IsSuperType 

func (t *FixedPointNumericType) IsSuperType() bool

func (*FixedPointNumericType) IsType 

func (*FixedPointNumericType) IsType()

func (*FixedPointNumericType) Map 

func (t *FixedPointNumericType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*FixedPointNumericType) MaxFractional 

func (t *FixedPointNumericType) MaxFractional() *big.Int

func (*FixedPointNumericType) MaxInt 

func (t *FixedPointNumericType) MaxInt() *big.Int

func (*FixedPointNumericType) MinFractional 

func (t *FixedPointNumericType) MinFractional() *big.Int

func (*FixedPointNumericType) MinInt 

func (t *FixedPointNumericType) MinInt() *big.Int

func (*FixedPointNumericType) QualifiedString 

func (t *FixedPointNumericType) QualifiedString() string

func (*FixedPointNumericType) Resolve 

func (t *FixedPointNumericType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*FixedPointNumericType) RewriteWithIntersectionTypes 

func (t *FixedPointNumericType) RewriteWithIntersectionTypes() (result Type, rewritten bool)

func (*FixedPointNumericType) Scale 

func (t *FixedPointNumericType) Scale() uint

func (*FixedPointNumericType) String 

func (t *FixedPointNumericType) String() string

func (*FixedPointNumericType) SupportsSaturatingAdd 

func (t *FixedPointNumericType) SupportsSaturatingAdd() bool

func (*FixedPointNumericType) SupportsSaturatingDivide 

func (t *FixedPointNumericType) SupportsSaturatingDivide() bool

func (*FixedPointNumericType) SupportsSaturatingMultiply 

func (t *FixedPointNumericType) SupportsSaturatingMultiply() bool

func (*FixedPointNumericType) SupportsSaturatingSubtract 

func (t *FixedPointNumericType) SupportsSaturatingSubtract() bool

func (*FixedPointNumericType) Tag 

func (t *FixedPointNumericType) Tag() TypeTag

func (*FixedPointNumericType) TypeAnnotationState 

func (*FixedPointNumericType) TypeAnnotationState() TypeAnnotationState

func (*FixedPointNumericType) Unify 

func (*FixedPointNumericType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

func (*FixedPointNumericType) WithFractionalRange 

func (t *FixedPointNumericType) WithFractionalRange(
	minFractional *big.Int,
	maxFractional *big.Int,
) *FixedPointNumericType

func (*FixedPointNumericType) WithIntRange 

func (t *FixedPointNumericType) WithIntRange(minInt *big.Int, maxInt *big.Int) *FixedPointNumericType

func (*FixedPointNumericType) WithSaturatingFunctions 

func (t *FixedPointNumericType) WithSaturatingFunctions(saturatingArithmetic SaturatingArithmeticSupport) *FixedPointNumericType

func (*FixedPointNumericType) WithScale 

func (t *FixedPointNumericType) WithScale(scale uint) *FixedPointNumericType

func (*FixedPointNumericType) WithTag 

func (t *FixedPointNumericType) WithTag(tag TypeTag) *FixedPointNumericType

type ForStatementTypes 

type ForStatementTypes struct {
	IndexVariableType Type
	ValueVariableType Type
}

type FractionalRangedType 

type FractionalRangedType interface {
	IntegerRangedType
	Scale() uint
	MinFractional() *big.Int
	MaxFractional() *big.Int
}

type FunctionActivation 

type FunctionActivation struct {
	ReturnType           Type
	ReturnInfo           *ReturnInfo
	InitializationInfo   *InitializationInfo
	Loops                int
	Switches             int
	ValueActivationDepth int
}

func (FunctionActivation) InLoop 

func (a FunctionActivation) InLoop() bool

func (FunctionActivation) InSwitch 

func (a FunctionActivation) InSwitch() bool

func (*FunctionActivation) WithLoop 

func (a *FunctionActivation) WithLoop(f func())

func (*FunctionActivation) WithSwitch 

func (a *FunctionActivation) WithSwitch(f func())

type FunctionActivations 

type FunctionActivations struct {
	// contains filtered or unexported fields
}

func (*FunctionActivations) Current 

func (a *FunctionActivations) Current() *FunctionActivation

func (*FunctionActivations) EnterFunction 

func (a *FunctionActivations) EnterFunction(functionType *FunctionType, valueActivationDepth int) *FunctionActivation

func (*FunctionActivations) IsLocal 

func (a *FunctionActivations) IsLocal() bool

func (*FunctionActivations) LeaveFunction 

func (a *FunctionActivations) LeaveFunction()

func (*FunctionActivations) WithFunction 

func (a *FunctionActivations) WithFunction(
	functionType *FunctionType,
	valueActivationDepth int,
	f func(activation *FunctionActivation),
)

type FunctionExpressionInConditionError 

type FunctionExpressionInConditionError struct {
	ast.Range
}

func (*FunctionExpressionInConditionError) Error 

func (e *FunctionExpressionInConditionError) Error() string

func (*FunctionExpressionInConditionError) IsUserError 

func (*FunctionExpressionInConditionError) IsUserError()

type FunctionInvocation 

type FunctionInvocation struct {
	FunctionType               *FunctionType
	TrailingSeparatorPositions []ast.Position
	StartPos                   Position
	EndPos                     Position
}

type FunctionInvocations 

type FunctionInvocations struct {
	// contains filtered or unexported fields
}

func NewFunctionInvocations 

func NewFunctionInvocations() *FunctionInvocations

func (*FunctionInvocations) Find 

func (f *FunctionInvocations) Find(pos Position) *FunctionInvocation

func (*FunctionInvocations) Put 

func (f *FunctionInvocations) Put(
	startPos, endPos ast.Position,
	functionType *FunctionType,
	trailingSeparatorPositions []ast.Position,
)

type FunctionPurity 

type FunctionPurity int

func PurityFromAnnotation 

func PurityFromAnnotation(purity ast.FunctionPurity) FunctionPurity

func (FunctionPurity) String 

func (p FunctionPurity) String() string

type FunctionType 

type FunctionType struct {
	Purity                   FunctionPurity
	ReturnTypeAnnotation     TypeAnnotation
	Arity                    *Arity
	ArgumentExpressionsCheck ArgumentExpressionsCheck
	TypeArgumentsCheck       TypeArgumentsCheck
	Members                  *StringMemberOrderedMap
	TypeParameters           []*TypeParameter
	Parameters               []Parameter

	IsConstructor bool
	// contains filtered or unexported fields
}

func ArrayAppendAllFunctionType 

func ArrayAppendAllFunctionType(arrayType Type) *FunctionType

func ArrayAppendFunctionType 

func ArrayAppendFunctionType(elementType Type) *FunctionType

func ArrayConcatFunctionType 

func ArrayConcatFunctionType(arrayType Type) *FunctionType

func ArrayContainsFunctionType 

func ArrayContainsFunctionType(elementType Type) *FunctionType

func ArrayFilterFunctionType 

func ArrayFilterFunctionType(memoryGauge common.MemoryGauge, elementType Type) *FunctionType

func ArrayFirstIndexFunctionType 

func ArrayFirstIndexFunctionType(elementType Type) *FunctionType

func ArrayInsertFunctionType 

func ArrayInsertFunctionType(elementType Type) *FunctionType

func ArrayMapFunctionType 

func ArrayMapFunctionType(memoryGauge common.MemoryGauge, arrayType ArrayType) *FunctionType

func ArrayRemoveFirstFunctionType 

func ArrayRemoveFirstFunctionType(elementType Type) *FunctionType

func ArrayRemoveFunctionType 

func ArrayRemoveFunctionType(elementType Type) *FunctionType

func ArrayRemoveLastFunctionType 

func ArrayRemoveLastFunctionType(elementType Type) *FunctionType

func ArrayReverseFunctionType 

func ArrayReverseFunctionType(arrayType ArrayType) *FunctionType

func ArraySliceFunctionType 

func ArraySliceFunctionType(elementType Type) *FunctionType

func ArrayToConstantSizedFunctionType 

func ArrayToConstantSizedFunctionType(elementType Type) *FunctionType

func ArrayToVariableSizedFunctionType 

func ArrayToVariableSizedFunctionType(elementType Type) *FunctionType

func CapabilityTypeBorrowFunctionType 

func CapabilityTypeBorrowFunctionType(borrowType Type) *FunctionType

func CapabilityTypeCheckFunctionType 

func CapabilityTypeCheckFunctionType(borrowType Type) *FunctionType

func CompositeForEachAttachmentFunctionType 

func CompositeForEachAttachmentFunctionType(t common.CompositeKind) *FunctionType

func CompositeLikeConstructorType 

func CompositeLikeConstructorType(
	elaboration *Elaboration,
	compositeDeclaration ast.CompositeLikeDeclaration,
	compositeType *CompositeType,
) (
	constructorFunctionType *FunctionType,
	argumentLabels []string,
)

func DictionaryContainsKeyFunctionType 

func DictionaryContainsKeyFunctionType(t *DictionaryType) *FunctionType

func DictionaryForEachKeyFunctionType 

func DictionaryForEachKeyFunctionType(t *DictionaryType) *FunctionType

func DictionaryInsertFunctionType 

func DictionaryInsertFunctionType(t *DictionaryType) *FunctionType

func DictionaryRemoveFunctionType 

func DictionaryRemoveFunctionType(t *DictionaryType) *FunctionType

func EnumConstructorType 

func EnumConstructorType(compositeType *CompositeType) *FunctionType

func FromBigEndianBytesFunctionType 

func FromBigEndianBytesFunctionType(ty Type) *FunctionType

func FromStringFunctionType 

func FromStringFunctionType(ty Type) *FunctionType

func InclusiveRangeContainsFunctionType 

func InclusiveRangeContainsFunctionType(elementType Type) *FunctionType

func NewSimpleFunctionType 

func NewSimpleFunctionType(
	purity FunctionPurity,
	parameters []Parameter,
	returnTypeAnnotation TypeAnnotation,
) *FunctionType

func NumberConversionFunctionType 

func NumberConversionFunctionType(numberType Type) *FunctionType

func OptionalTypeMapFunctionType 

func OptionalTypeMapFunctionType(typ Type) *FunctionType

func (*FunctionType) ArgumentLabels 

func (t *FunctionType) ArgumentLabels() (argumentLabels []string)

func (*FunctionType) CheckInstantiated 

func (t *FunctionType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*FunctionType) ContainFieldsOrElements 

func (*FunctionType) ContainFieldsOrElements() bool

func (*FunctionType) Equal 

func (t *FunctionType) Equal(other Type) bool

NOTE: parameter names and argument labels are intentionally *not* considered!

func (*FunctionType) GetMembers 

func (t *FunctionType) GetMembers() map[string]MemberResolver

func (*FunctionType) HasSameArgumentLabels 

func (t *FunctionType) HasSameArgumentLabels(other *FunctionType) bool

func (*FunctionType) ID 

func (t *FunctionType) ID() TypeID

NOTE: parameter names and argument labels are *not* part of the ID!

func (*FunctionType) IsComparable 

func (*FunctionType) IsComparable() bool

func (*FunctionType) IsEquatable 

func (*FunctionType) IsEquatable() bool

func (*FunctionType) IsExportable 

func (t *FunctionType) IsExportable(_ map[*Member]bool) bool

func (*FunctionType) IsImportable 

func (t *FunctionType) IsImportable(_ map[*Member]bool) bool

func (*FunctionType) IsInvalidType 

func (t *FunctionType) IsInvalidType() bool

func (*FunctionType) IsOrContainsReferenceType 

func (*FunctionType) IsOrContainsReferenceType() bool

func (*FunctionType) IsPrimitiveType 

func (t *FunctionType) IsPrimitiveType() bool

func (*FunctionType) IsResourceType 

func (*FunctionType) IsResourceType() bool

func (*FunctionType) IsStorable 

func (t *FunctionType) IsStorable(_ map[*Member]bool) bool

func (*FunctionType) IsType 

func (*FunctionType) IsType()

func (*FunctionType) Map 

func (t *FunctionType) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*FunctionType) NamedQualifiedString 

func (t *FunctionType) NamedQualifiedString(functionName string) string

func (*FunctionType) ParameterTypes 

func (t *FunctionType) ParameterTypes() []Type

func (*FunctionType) QualifiedString 

func (t *FunctionType) QualifiedString() string

func (*FunctionType) Resolve 

func (t *FunctionType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*FunctionType) RewriteWithIntersectionTypes 

func (t *FunctionType) RewriteWithIntersectionTypes() (Type, bool)

func (*FunctionType) String 

func (t *FunctionType) String() string

func (*FunctionType) Tag 

func (t *FunctionType) Tag() TypeTag

func (*FunctionType) TypeAnnotationState 

func (t *FunctionType) TypeAnnotationState() TypeAnnotationState

func (*FunctionType) Unify 

func (t *FunctionType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) (
	result bool,
)

type GenericType 

type GenericType struct {
	TypeParameter *TypeParameter
}

GenericType

func (*GenericType) CheckInstantiated 

func (t *GenericType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*GenericType) ContainFieldsOrElements 

func (t *GenericType) ContainFieldsOrElements() bool

func (*GenericType) Equal 

func (t *GenericType) Equal(other Type) bool

func (*GenericType) GetMembers 

func (t *GenericType) GetMembers() map[string]MemberResolver

func (*GenericType) ID 

func (t *GenericType) ID() TypeID

func (*GenericType) IsComparable 

func (*GenericType) IsComparable() bool

func (*GenericType) IsEquatable 

func (*GenericType) IsEquatable() bool

func (*GenericType) IsExportable 

func (*GenericType) IsExportable(_ map[*Member]bool) bool

func (*GenericType) IsImportable 

func (t *GenericType) IsImportable(_ map[*Member]bool) bool

func (*GenericType) IsInvalidType 

func (*GenericType) IsInvalidType() bool

func (*GenericType) IsOrContainsReferenceType 

func (*GenericType) IsOrContainsReferenceType() bool

func (*GenericType) IsPrimitiveType 

func (*GenericType) IsPrimitiveType() bool

func (*GenericType) IsResourceType 

func (*GenericType) IsResourceType() bool

func (*GenericType) IsStorable 

func (*GenericType) IsStorable(_ map[*Member]bool) bool

func (*GenericType) IsType 

func (*GenericType) IsType()

func (*GenericType) Map 

func (t *GenericType) Map(_ common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*GenericType) QualifiedString 

func (t *GenericType) QualifiedString() string

func (*GenericType) Resolve 

func (t *GenericType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*GenericType) RewriteWithIntersectionTypes 

func (t *GenericType) RewriteWithIntersectionTypes() (result Type, rewritten bool)

func (*GenericType) String 

func (t *GenericType) String() string

func (*GenericType) Tag 

func (t *GenericType) Tag() TypeTag

func (*GenericType) TypeAnnotationState 

func (*GenericType) TypeAnnotationState() TypeAnnotationState

func (*GenericType) Unify 

func (t *GenericType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type HashAlgorithm 

type HashAlgorithm uint8
const (
	HashAlgorithmUnknown HashAlgorithm = iota
	HashAlgorithmSHA2_256
	HashAlgorithmSHA2_384
	HashAlgorithmSHA3_256
	HashAlgorithmSHA3_384
	HashAlgorithmKMAC128_BLS_BLS12_381
	HashAlgorithmKECCAK_256
)
  • Existing stored values use these raw values and should not change

NOTE: only add new algorithms, do *NOT* change existing items, reuse raw values for other items, swap the order, etc.

Existing stored values use these raw values and should not change

IMPORTANT: update HashAlgorithms AND HashAlgorithm.IsValid

func (HashAlgorithm) DocString 

func (algo HashAlgorithm) DocString() string

func (HashAlgorithm) IsValid 

func (algo HashAlgorithm) IsValid() bool

func (HashAlgorithm) Name 

func (algo HashAlgorithm) Name() string

func (HashAlgorithm) RawValue 

func (algo HashAlgorithm) RawValue() uint8

func (HashAlgorithm) String 

func (i HashAlgorithm) String() string

type Import 

type Import interface {
	AllValueElements() *StringImportElementOrderedMap
	AllTypeElements() *StringImportElementOrderedMap
	IsChecking() bool
}

type ImportElement 

type ImportElement struct {
	Type            Type
	ArgumentLabels  []string
	DeclarationKind common.DeclarationKind
	Access          Access
}

ImportElement

type ImportHandlerFunc 

type ImportHandlerFunc func(checker *Checker, importedLocation common.Location, importRange ast.Range) (Import, error)

type ImportedProgramError 

type ImportedProgramError struct {
	Err      error
	Location common.Location
	ast.Range
}

func (*ImportedProgramError) ChildErrors 

func (e *ImportedProgramError) ChildErrors() []error

func (*ImportedProgramError) Error 

func (e *ImportedProgramError) Error() string

func (*ImportedProgramError) ImportLocation 

func (e *ImportedProgramError) ImportLocation() common.Location

func (*ImportedProgramError) IsUserError 

func (*ImportedProgramError) IsUserError()

func (*ImportedProgramError) Unwrap 

func (e *ImportedProgramError) Unwrap() error

type InclusiveRangeType 

type InclusiveRangeType struct {
	MemberType Type
	// contains filtered or unexported fields
}

func NewInclusiveRangeType 

func NewInclusiveRangeType(memoryGauge common.MemoryGauge, elementType Type) *InclusiveRangeType

func (*InclusiveRangeType) AllowsValueIndexingAssignment 

func (*InclusiveRangeType) AllowsValueIndexingAssignment() bool

func (*InclusiveRangeType) BaseType 

func (t *InclusiveRangeType) BaseType() Type

func (*InclusiveRangeType) CheckInstantiated 

func (t *InclusiveRangeType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*InclusiveRangeType) ContainFieldsOrElements 

func (t *InclusiveRangeType) ContainFieldsOrElements() bool

func (*InclusiveRangeType) Equal 

func (t *InclusiveRangeType) Equal(other Type) bool

func (*InclusiveRangeType) GetMembers 

func (t *InclusiveRangeType) GetMembers() map[string]MemberResolver

func (*InclusiveRangeType) ID 

func (t *InclusiveRangeType) ID() TypeID

func (*InclusiveRangeType) Instantiate 

func (t *InclusiveRangeType) Instantiate(
	memoryGauge common.MemoryGauge,
	typeArguments []Type,
	astTypeArguments []*ast.TypeAnnotation,
	report func(err error),
) Type

func (*InclusiveRangeType) IsComparable 

func (*InclusiveRangeType) IsComparable() bool

func (*InclusiveRangeType) IsEquatable 

func (t *InclusiveRangeType) IsEquatable() bool

func (*InclusiveRangeType) IsExportable 

func (t *InclusiveRangeType) IsExportable(results map[*Member]bool) bool

func (*InclusiveRangeType) IsImportable 

func (t *InclusiveRangeType) IsImportable(results map[*Member]bool) bool

func (*InclusiveRangeType) IsInvalidType 

func (t *InclusiveRangeType) IsInvalidType() bool

func (*InclusiveRangeType) IsOrContainsReferenceType 

func (t *InclusiveRangeType) IsOrContainsReferenceType() bool

func (*InclusiveRangeType) IsPrimitiveType 

func (t *InclusiveRangeType) IsPrimitiveType() bool

func (*InclusiveRangeType) IsResourceType 

func (*InclusiveRangeType) IsResourceType() bool

func (*InclusiveRangeType) IsStorable 

func (*InclusiveRangeType) IsStorable(_ map[*Member]bool) bool

func (*InclusiveRangeType) IsType 

func (*InclusiveRangeType) IsType()

func (*InclusiveRangeType) Map 

func (t *InclusiveRangeType) Map(
	gauge common.MemoryGauge,
	typeParamMap map[*TypeParameter]*TypeParameter,
	f func(Type) Type,
) Type

func (*InclusiveRangeType) QualifiedString 

func (t *InclusiveRangeType) QualifiedString() string

func (*InclusiveRangeType) Resolve 

func (t *InclusiveRangeType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*InclusiveRangeType) RewriteWithIntersectionTypes 

func (t *InclusiveRangeType) RewriteWithIntersectionTypes() (Type, bool)

func (*InclusiveRangeType) String 

func (t *InclusiveRangeType) String() string

func (*InclusiveRangeType) Tag 

func (*InclusiveRangeType) Tag() TypeTag

func (*InclusiveRangeType) TypeAnnotationState 

func (t *InclusiveRangeType) TypeAnnotationState() TypeAnnotationState

func (*InclusiveRangeType) TypeArguments 

func (t *InclusiveRangeType) TypeArguments() []Type

func (*InclusiveRangeType) TypeParameters 

func (*InclusiveRangeType) TypeParameters() []*TypeParameter

func (*InclusiveRangeType) Unify 

func (t *InclusiveRangeType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type IncorrectArgumentLabelError 

type IncorrectArgumentLabelError struct {
	ExpectedArgumentLabel string
	ActualArgumentLabel   string
	ast.Range
}

func (*IncorrectArgumentLabelError) Error 

func (e *IncorrectArgumentLabelError) Error() string

func (*IncorrectArgumentLabelError) IsUserError 

func (*IncorrectArgumentLabelError) IsUserError()

func (*IncorrectArgumentLabelError) SecondaryError 

func (e *IncorrectArgumentLabelError) SecondaryError() string

func (*IncorrectArgumentLabelError) SuggestFixes 

func (e *IncorrectArgumentLabelError) SuggestFixes(code string) []errors.SuggestedFix[ast.TextEdit]

type IncorrectTransferOperationError 

type IncorrectTransferOperationError struct {
	ActualOperation   ast.TransferOperation
	ExpectedOperation ast.TransferOperation
	ast.Range
}

func (*IncorrectTransferOperationError) Error 

func (e *IncorrectTransferOperationError) Error() string

func (*IncorrectTransferOperationError) IsUserError 

func (*IncorrectTransferOperationError) IsUserError()

func (*IncorrectTransferOperationError) SecondaryError 

func (e *IncorrectTransferOperationError) SecondaryError() string

type IndexExpressionTypes 

type IndexExpressionTypes struct {
	IndexedType     ValueIndexableType
	IndexingType    Type
	ResultType      Type
	ReturnReference bool
}

type InitializationInfo 

type InitializationInfo struct {
	ContainerType           Type
	FieldMembers            *MemberFieldDeclarationOrderedMap
	InitializedFieldMembers *persistent.OrderedSet[*Member]
}

func NewInitializationInfo 

func NewInitializationInfo(
	containerType Type,
	fieldMembers *MemberFieldDeclarationOrderedMap,
) *InitializationInfo

func (*InitializationInfo) InitializationComplete 

func (info *InitializationInfo) InitializationComplete() bool

InitializationComplete returns true if all fields of the container were initialized, false if some fields are uninitialized

type InitializerMismatch 

type InitializerMismatch struct {
	CompositePurity     FunctionPurity
	InterfacePurity     FunctionPurity
	CompositeParameters []Parameter
	InterfaceParameters []Parameter
}

type InsufficientArgumentsError 

type InsufficientArgumentsError struct {
	MinCount    int
	ActualCount int
	ast.Range
}

func (*InsufficientArgumentsError) Error 

func (e *InsufficientArgumentsError) Error() string

func (*InsufficientArgumentsError) IsUserError 

func (*InsufficientArgumentsError) IsUserError()

func (*InsufficientArgumentsError) SecondaryError 

func (e *InsufficientArgumentsError) SecondaryError() string

type IntegerRangedType 

type IntegerRangedType interface {
	Type
	MinInt() *big.Int
	MaxInt() *big.Int
	IsSuperType() bool
}

type InterfaceMemberConflictError 

type InterfaceMemberConflictError struct {
	InterfaceType            *InterfaceType
	ConflictingInterfaceType *InterfaceType
	MemberName               string
	MemberKind               common.DeclarationKind
	ConflictingMemberKind    common.DeclarationKind
	ast.Range
}

InterfaceMemberConflictError

func (*InterfaceMemberConflictError) Error 

func (e *InterfaceMemberConflictError) Error() string

func (*InterfaceMemberConflictError) IsUserError 

func (*InterfaceMemberConflictError) IsUserError()

type InterfaceSet 

type InterfaceSet orderedmap.OrderedMap[*InterfaceType, struct{}]

func NewInterfaceSet 

func NewInterfaceSet() *InterfaceSet

func (*InterfaceSet) Add 

func (s *InterfaceSet) Add(interfaceType *InterfaceType)

func (InterfaceSet) Contains 

func (s InterfaceSet) Contains(interfaceType *InterfaceType) bool

func (InterfaceSet) ForEach 

func (s InterfaceSet) ForEach(f func(*InterfaceType))

func (InterfaceSet) IsSubsetOf 

func (s InterfaceSet) IsSubsetOf(other *InterfaceSet) bool

func (InterfaceSet) Len 

func (s InterfaceSet) Len() int

type InterfaceType 

type InterfaceType struct {
	Location common.Location

	Members *StringMemberOrderedMap

	NestedTypes *StringTypeOrderedMap

	Identifier            string
	Fields                []string
	InitializerParameters []Parameter
	CompositeKind         common.CompositeKind

	InitializerPurity FunctionPurity

	ExplicitInterfaceConformances []*InterfaceType

	DefaultDestroyEvent *CompositeType
	// contains filtered or unexported fields
}

func (*InterfaceType) CheckInstantiated 

func (t *InterfaceType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*InterfaceType) ContainFieldsOrElements 

func (*InterfaceType) ContainFieldsOrElements() bool

func (*InterfaceType) EffectiveInterfaceConformanceSet 

func (t *InterfaceType) EffectiveInterfaceConformanceSet() *InterfaceSet

func (*InterfaceType) EffectiveInterfaceConformances 

func (t *InterfaceType) EffectiveInterfaceConformances() []Conformance

func (*InterfaceType) Equal 

func (t *InterfaceType) Equal(other Type) bool

func (*InterfaceType) FieldPosition 

func (t *InterfaceType) FieldPosition(name string, declaration *ast.InterfaceDeclaration) ast.Position

func (*InterfaceType) GetCompositeKind 

func (t *InterfaceType) GetCompositeKind() common.CompositeKind

func (*InterfaceType) GetContainerType 

func (t *InterfaceType) GetContainerType() Type

func (*InterfaceType) GetLocation 

func (t *InterfaceType) GetLocation() common.Location

func (*InterfaceType) GetMembers 

func (t *InterfaceType) GetMembers() map[string]MemberResolver

func (*InterfaceType) GetNestedTypes 

func (t *InterfaceType) GetNestedTypes() *StringTypeOrderedMap

func (*InterfaceType) ID 

func (t *InterfaceType) ID() TypeID

func (*InterfaceType) IsComparable 

func (*InterfaceType) IsComparable() bool

func (*InterfaceType) IsContainerType 

func (t *InterfaceType) IsContainerType() bool

func (*InterfaceType) IsEquatable 

func (*InterfaceType) IsEquatable() bool

func (*InterfaceType) IsExportable 

func (t *InterfaceType) IsExportable(results map[*Member]bool) bool

func (*InterfaceType) IsImportable 

func (t *InterfaceType) IsImportable(results map[*Member]bool) bool

func (*InterfaceType) IsInvalidType 

func (*InterfaceType) IsInvalidType() bool

func (*InterfaceType) IsOrContainsReferenceType 

func (*InterfaceType) IsOrContainsReferenceType() bool

func (*InterfaceType) IsPrimitiveType 

func (*InterfaceType) IsPrimitiveType() bool

func (*InterfaceType) IsResourceType 

func (t *InterfaceType) IsResourceType() bool

func (*InterfaceType) IsStorable 

func (t *InterfaceType) IsStorable(results map[*Member]bool) bool

func (*InterfaceType) IsType 

func (*InterfaceType) IsType()

func (*InterfaceType) Map 

func (t *InterfaceType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*InterfaceType) MemberMap 

func (t *InterfaceType) MemberMap() *StringMemberOrderedMap

func (*InterfaceType) QualifiedIdentifier 

func (t *InterfaceType) QualifiedIdentifier() string

func (*InterfaceType) QualifiedString 

func (t *InterfaceType) QualifiedString() string

func (*InterfaceType) Resolve 

func (t *InterfaceType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*InterfaceType) RewriteWithIntersectionTypes 

func (t *InterfaceType) RewriteWithIntersectionTypes() (Type, bool)

func (*InterfaceType) SetContainerType 

func (t *InterfaceType) SetContainerType(containerType Type)

func (*InterfaceType) String 

func (t *InterfaceType) String() string

func (*InterfaceType) SupportedEntitlements 

func (t *InterfaceType) SupportedEntitlements() *EntitlementSet

func (*InterfaceType) Tag 

func (t *InterfaceType) Tag() TypeTag

func (*InterfaceType) TypeAnnotationState 

func (*InterfaceType) TypeAnnotationState() TypeAnnotationState

func (*InterfaceType) Unify 

func (*InterfaceType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type IntersectionCompositeKindMismatchError 

type IntersectionCompositeKindMismatchError struct {
	CompositeKind         common.CompositeKind
	PreviousCompositeKind common.CompositeKind
	ast.Range
}

func (*IntersectionCompositeKindMismatchError) Error 

func (e *IntersectionCompositeKindMismatchError) Error() string

func (*IntersectionCompositeKindMismatchError) IsUserError 

func (*IntersectionCompositeKindMismatchError) IsUserError()

type IntersectionMemberClashError 

type IntersectionMemberClashError struct {
	RedeclaringType       *InterfaceType
	OriginalDeclaringType *InterfaceType
	Name                  string
	ast.Range
}

func (*IntersectionMemberClashError) Error 

func (e *IntersectionMemberClashError) Error() string

func (*IntersectionMemberClashError) IsUserError 

func (*IntersectionMemberClashError) IsUserError()

type IntersectionType 

type IntersectionType struct {
	Types []*InterfaceType

	// Deprecated
	LegacyType Type
	// contains filtered or unexported fields
}

func NewIntersectionType 

func NewIntersectionType(memoryGauge common.MemoryGauge, legacyType Type, types []*InterfaceType) *IntersectionType

TODO: remove `legacyType` once all uses of it are removed

func (*IntersectionType) CheckInstantiated 

func (t *IntersectionType) CheckInstantiated(_ ast.HasPosition, _ common.MemoryGauge, _ func(err error))

func (*IntersectionType) ContainFieldsOrElements 

func (*IntersectionType) ContainFieldsOrElements() bool

func (*IntersectionType) EffectiveIntersectionSet 

func (t *IntersectionType) EffectiveIntersectionSet() *InterfaceSet

func (*IntersectionType) Equal 

func (t *IntersectionType) Equal(other Type) bool

func (*IntersectionType) GetMembers 

func (t *IntersectionType) GetMembers() map[string]MemberResolver

func (*IntersectionType) ID 

func (t *IntersectionType) ID() TypeID

func (*IntersectionType) IsComparable 

func (t *IntersectionType) IsComparable() bool

func (*IntersectionType) IsEquatable 

func (*IntersectionType) IsEquatable() bool

func (*IntersectionType) IsExportable 

func (t *IntersectionType) IsExportable(results map[*Member]bool) bool

func (*IntersectionType) IsImportable 

func (t *IntersectionType) IsImportable(results map[*Member]bool) bool

func (*IntersectionType) IsInvalidType 

func (t *IntersectionType) IsInvalidType() bool

func (*IntersectionType) IsOrContainsReferenceType 

func (t *IntersectionType) IsOrContainsReferenceType() bool

func (*IntersectionType) IsPrimitiveType 

func (*IntersectionType) IsPrimitiveType() bool

func (*IntersectionType) IsResourceType 

func (t *IntersectionType) IsResourceType() bool

func (*IntersectionType) IsStorable 

func (t *IntersectionType) IsStorable(results map[*Member]bool) bool

func (*IntersectionType) IsType 

func (*IntersectionType) IsType()

func (*IntersectionType) IsValidIndexingType 

func (t *IntersectionType) IsValidIndexingType(ty Type) bool

func (*IntersectionType) Map 

func (t *IntersectionType) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*IntersectionType) QualifiedString 

func (t *IntersectionType) QualifiedString() string

func (*IntersectionType) Resolve 

func (t *IntersectionType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*IntersectionType) RewriteWithIntersectionTypes 

func (t *IntersectionType) RewriteWithIntersectionTypes() (Type, bool)

func (*IntersectionType) String 

func (t *IntersectionType) String() string

func (*IntersectionType) SupportedEntitlements 

func (t *IntersectionType) SupportedEntitlements() *EntitlementSet

func (*IntersectionType) Tag 

func (t *IntersectionType) Tag() TypeTag

func (*IntersectionType) TypeAnnotationState 

func (*IntersectionType) TypeAnnotationState() TypeAnnotationState

func (*IntersectionType) TypeIndexingElementType 

func (t *IntersectionType) TypeIndexingElementType(indexingType Type, _ func() ast.Range) (Type, error)

func (*IntersectionType) Unify 

func (*IntersectionType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type InvalidAccessError 

type InvalidAccessError struct {
	Name              string
	RestrictingAccess Access
	PossessedAccess   Access
	DeclarationKind   common.DeclarationKind

	ast.Range
	// contains filtered or unexported fields
}

func (*InvalidAccessError) Error 

func (e *InvalidAccessError) Error() string

func (*InvalidAccessError) IsUserError 

func (*InvalidAccessError) IsUserError()

func (*InvalidAccessError) SecondaryError 

func (e *InvalidAccessError) SecondaryError() string

When e.PossessedAccess is a conjunctive entitlement set, we can suggest which additional entitlements it would need to be given in order to have e.RequiredAccess.

type InvalidAccessModifierError 

type InvalidAccessModifierError struct {
	Explanation     string
	Pos             ast.Position
	DeclarationKind common.DeclarationKind
	Access          Access
}

func (*InvalidAccessModifierError) EndPosition 

func (e *InvalidAccessModifierError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*InvalidAccessModifierError) Error 

func (e *InvalidAccessModifierError) Error() string

func (*InvalidAccessModifierError) IsUserError 

func (*InvalidAccessModifierError) IsUserError()

func (*InvalidAccessModifierError) StartPosition 

func (e *InvalidAccessModifierError) StartPosition() ast.Position

type InvalidAddressLiteralError 

type InvalidAddressLiteralError struct {
	ast.Range
}

func (*InvalidAddressLiteralError) Error 

func (e *InvalidAddressLiteralError) Error() string

func (*InvalidAddressLiteralError) IsUserError 

func (*InvalidAddressLiteralError) IsUserError()

type InvalidAssignmentAccessError 

type InvalidAssignmentAccessError struct {
	Name              string
	ContainerType     Type
	RestrictingAccess Access
	DeclarationKind   common.DeclarationKind
	ast.Range
}

func (*InvalidAssignmentAccessError) Error 

func (e *InvalidAssignmentAccessError) Error() string

func (*InvalidAssignmentAccessError) IsUserError 

func (*InvalidAssignmentAccessError) IsUserError()

func (*InvalidAssignmentAccessError) SecondaryError 

func (e *InvalidAssignmentAccessError) SecondaryError() string

type InvalidAssignmentTargetError 

type InvalidAssignmentTargetError struct {
	ast.Range
}

func (*InvalidAssignmentTargetError) Error 

func (e *InvalidAssignmentTargetError) Error() string

func (*InvalidAssignmentTargetError) IsUserError 

func (*InvalidAssignmentTargetError) IsUserError()

type InvalidAttachmentAnnotationError 

type InvalidAttachmentAnnotationError struct {
	ast.Range
}

func (*InvalidAttachmentAnnotationError) Error 

func (e *InvalidAttachmentAnnotationError) Error() string

func (*InvalidAttachmentAnnotationError) IsUserError 

func (*InvalidAttachmentAnnotationError) IsUserError()

type InvalidAttachmentConformancesError added in v1.2.2 

type InvalidAttachmentConformancesError struct {
	ast.Range
}

func (*InvalidAttachmentConformancesError) Error added in v1.2.2 

func (e *InvalidAttachmentConformancesError) Error() string

func (*InvalidAttachmentConformancesError) IsUserError added in v1.2.2 

func (*InvalidAttachmentConformancesError) IsUserError()

type InvalidAttachmentEntitlementError 

type InvalidAttachmentEntitlementError struct {
	Attachment         *CompositeType
	BaseType           Type
	InvalidEntitlement *EntitlementType
	Pos                ast.Position
}

InvalidAttachmentEntitlementError

func (*InvalidAttachmentEntitlementError) EndPosition 

func (e *InvalidAttachmentEntitlementError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidAttachmentEntitlementError) Error 

func (e *InvalidAttachmentEntitlementError) Error() string

func (*InvalidAttachmentEntitlementError) IsUserError 

func (*InvalidAttachmentEntitlementError) IsUserError()

func (*InvalidAttachmentEntitlementError) SecondaryError 

func (e *InvalidAttachmentEntitlementError) SecondaryError() string

func (*InvalidAttachmentEntitlementError) StartPosition 

func (e *InvalidAttachmentEntitlementError) StartPosition() ast.Position

type InvalidAttachmentMappedEntitlementMemberError 

type InvalidAttachmentMappedEntitlementMemberError struct {
	Pos ast.Position
}

InvalidAttachmentMappedEntitlementMemberError

func (*InvalidAttachmentMappedEntitlementMemberError) EndPosition 

func (e *InvalidAttachmentMappedEntitlementMemberError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidAttachmentMappedEntitlementMemberError) Error 

func (e *InvalidAttachmentMappedEntitlementMemberError) Error() string

func (*InvalidAttachmentMappedEntitlementMemberError) IsUserError 

func (*InvalidAttachmentMappedEntitlementMemberError) IsUserError()

func (*InvalidAttachmentMappedEntitlementMemberError) StartPosition 

func (e *InvalidAttachmentMappedEntitlementMemberError) StartPosition() ast.Position

type InvalidAttachmentRemoveError 

type InvalidAttachmentRemoveError struct {
	Attachment Type
	BaseType   Type
	ast.Range
}

InvalidAttachmentRemoveError

func (*InvalidAttachmentRemoveError) Error 

func (e *InvalidAttachmentRemoveError) Error() string

func (*InvalidAttachmentRemoveError) IsUserError 

func (*InvalidAttachmentRemoveError) IsUserError()

type InvalidAttachmentUsageError 

type InvalidAttachmentUsageError struct {
	ast.Range
}

func (*InvalidAttachmentUsageError) Error 

func (*InvalidAttachmentUsageError) Error() string

func (*InvalidAttachmentUsageError) IsUserError 

func (*InvalidAttachmentUsageError) IsUserError()

type InvalidBaseTypeError 

type InvalidBaseTypeError struct {
	BaseType   Type
	Attachment *CompositeType
	ast.Range
}

func (*InvalidBaseTypeError) Error 

func (e *InvalidBaseTypeError) Error() string

func (*InvalidBaseTypeError) IsUserError 

func (*InvalidBaseTypeError) IsUserError()

type InvalidBinaryOperandError 

type InvalidBinaryOperandError struct {
	ExpectedType Type
	ActualType   Type
	ast.Range
	Operation ast.Operation
	Side      common.OperandSide
}

func (*InvalidBinaryOperandError) Error 

func (e *InvalidBinaryOperandError) Error() string

func (*InvalidBinaryOperandError) IsUserError 

func (*InvalidBinaryOperandError) IsUserError()

func (*InvalidBinaryOperandError) SecondaryError 

func (e *InvalidBinaryOperandError) SecondaryError() string

type InvalidBinaryOperandsError 

type InvalidBinaryOperandsError struct {
	LeftType  Type
	RightType Type
	ast.Range
	Operation ast.Operation
}

func (*InvalidBinaryOperandsError) Error 

func (e *InvalidBinaryOperandsError) Error() string

func (*InvalidBinaryOperandsError) IsUserError 

func (*InvalidBinaryOperandsError) IsUserError()

type InvalidCharacterLiteralError 

type InvalidCharacterLiteralError struct {
	Length int
	ast.Range
}

func (*InvalidCharacterLiteralError) Error 

func (e *InvalidCharacterLiteralError) Error() string

func (*InvalidCharacterLiteralError) IsUserError 

func (*InvalidCharacterLiteralError) IsUserError()

func (*InvalidCharacterLiteralError) SecondaryError 

func (e *InvalidCharacterLiteralError) SecondaryError() string

type InvalidConditionalResourceOperandError 

type InvalidConditionalResourceOperandError struct {
	ast.Range
}

func (*InvalidConditionalResourceOperandError) Error 

func (e *InvalidConditionalResourceOperandError) Error() string

type InvalidConformanceError 

type InvalidConformanceError struct {
	Type Type
	ast.Range
}

func (*InvalidConformanceError) Error 

func (e *InvalidConformanceError) Error() string

func (*InvalidConformanceError) IsUserError 

func (*InvalidConformanceError) IsUserError()

type InvalidConstantSizedTypeBaseError 

type InvalidConstantSizedTypeBaseError struct {
	ActualBase   int
	ExpectedBase int
	ast.Range
}

func (*InvalidConstantSizedTypeBaseError) Error 

func (e *InvalidConstantSizedTypeBaseError) Error() string

func (*InvalidConstantSizedTypeBaseError) IsUserError 

func (*InvalidConstantSizedTypeBaseError) IsUserError()

func (*InvalidConstantSizedTypeBaseError) SecondaryError 

func (e *InvalidConstantSizedTypeBaseError) SecondaryError() string

type InvalidConstantSizedTypeSizeError 

type InvalidConstantSizedTypeSizeError struct {
	ActualSize     *big.Int
	ExpectedMinInt *big.Int
	ExpectedMaxInt *big.Int
	ast.Range
}

func (*InvalidConstantSizedTypeSizeError) Error 

func (e *InvalidConstantSizedTypeSizeError) Error() string

func (*InvalidConstantSizedTypeSizeError) IsUserError 

func (*InvalidConstantSizedTypeSizeError) IsUserError()

func (*InvalidConstantSizedTypeSizeError) SecondaryError 

func (e *InvalidConstantSizedTypeSizeError) SecondaryError() string

type InvalidConstructionError 

type InvalidConstructionError struct {
	ast.Range
}

func (*InvalidConstructionError) Error 

func (e *InvalidConstructionError) Error() string

func (*InvalidConstructionError) IsUserError 

func (*InvalidConstructionError) IsUserError()

type InvalidDeclarationError 

type InvalidDeclarationError struct {
	Identifier string
	Kind       common.DeclarationKind
	ast.Range
}

func (*InvalidDeclarationError) Error 

func (e *InvalidDeclarationError) Error() string

func (*InvalidDeclarationError) IsUserError 

func (*InvalidDeclarationError) IsUserError()

type InvalidDestructionError 

type InvalidDestructionError struct {
	ast.Range
}

func (*InvalidDestructionError) Error 

func (e *InvalidDestructionError) Error() string

func (*InvalidDestructionError) IsUserError 

func (*InvalidDestructionError) IsUserError()

type InvalidDictionaryKeyTypeError 

type InvalidDictionaryKeyTypeError struct {
	Type Type
	ast.Range
}

func (*InvalidDictionaryKeyTypeError) Error 

func (e *InvalidDictionaryKeyTypeError) Error() string

func (*InvalidDictionaryKeyTypeError) IsUserError 

func (*InvalidDictionaryKeyTypeError) IsUserError()

type InvalidEmitConditionError 

type InvalidEmitConditionError struct {
	ast.Range
}

func (*InvalidEmitConditionError) Error 

func (e *InvalidEmitConditionError) Error() string

func (*InvalidEmitConditionError) IsUserError 

func (*InvalidEmitConditionError) IsUserError()

type InvalidEntitlementAccessError 

type InvalidEntitlementAccessError struct {
	Pos ast.Position
}

InvalidEntitlementAccessError

func (*InvalidEntitlementAccessError) EndPosition 

func (e *InvalidEntitlementAccessError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidEntitlementAccessError) Error 

func (e *InvalidEntitlementAccessError) Error() string

func (*InvalidEntitlementAccessError) IsUserError 

func (*InvalidEntitlementAccessError) IsUserError()

func (*InvalidEntitlementAccessError) StartPosition 

func (e *InvalidEntitlementAccessError) StartPosition() ast.Position

type InvalidEntitlementMappingInclusionError 

type InvalidEntitlementMappingInclusionError struct {
	Map          *EntitlementMapType
	IncludedType Type
	ast.Range
}

InvalidEntitlementMappingInclusionError

func (*InvalidEntitlementMappingInclusionError) Error 

func (e *InvalidEntitlementMappingInclusionError) Error() string

func (*InvalidEntitlementMappingInclusionError) IsUserError 

func (*InvalidEntitlementMappingInclusionError) IsUserError()

type InvalidEntitlementMappingTypeError 

type InvalidEntitlementMappingTypeError struct {
	Type Type
	Pos  ast.Position
}

InvalidEntitlementMappingTypeError

func (*InvalidEntitlementMappingTypeError) EndPosition 

func (e *InvalidEntitlementMappingTypeError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidEntitlementMappingTypeError) Error 

func (e *InvalidEntitlementMappingTypeError) Error() string

func (*InvalidEntitlementMappingTypeError) IsUserError 

func (*InvalidEntitlementMappingTypeError) IsUserError()

func (*InvalidEntitlementMappingTypeError) SecondaryError 

func (e *InvalidEntitlementMappingTypeError) SecondaryError() string

func (*InvalidEntitlementMappingTypeError) StartPosition 

func (e *InvalidEntitlementMappingTypeError) StartPosition() ast.Position

type InvalidEntryPointTypeError 

type InvalidEntryPointTypeError struct {
	Type Type
}

func (*InvalidEntryPointTypeError) Error 

func (e *InvalidEntryPointTypeError) Error() string

func (*InvalidEntryPointTypeError) IsUserError 

func (*InvalidEntryPointTypeError) IsUserError()

type InvalidEnumCaseError 

type InvalidEnumCaseError struct {
	ContainerDeclarationKind common.DeclarationKind
	ast.Range
}

func (*InvalidEnumCaseError) Error 

func (e *InvalidEnumCaseError) Error() string

func (*InvalidEnumCaseError) IsUserError 

func (*InvalidEnumCaseError) IsUserError()

type InvalidEnumConformancesError 

type InvalidEnumConformancesError struct {
	ast.Range
}

func (*InvalidEnumConformancesError) Error 

func (e *InvalidEnumConformancesError) Error() string

func (*InvalidEnumConformancesError) IsUserError 

func (*InvalidEnumConformancesError) IsUserError()

type InvalidEnumRawTypeError 

type InvalidEnumRawTypeError struct {
	Type Type
	ast.Range
}

func (*InvalidEnumRawTypeError) Error 

func (e *InvalidEnumRawTypeError) Error() string

func (*InvalidEnumRawTypeError) IsUserError 

func (*InvalidEnumRawTypeError) IsUserError()

func (*InvalidEnumRawTypeError) SecondaryError 

func (e *InvalidEnumRawTypeError) SecondaryError() string

type InvalidEventParameterTypeError 

type InvalidEventParameterTypeError struct {
	Type Type
	ast.Range
}

func (*InvalidEventParameterTypeError) Error 

func (e *InvalidEventParameterTypeError) Error() string

func (*InvalidEventParameterTypeError) IsUserError 

func (*InvalidEventParameterTypeError) IsUserError()

type InvalidEventUsageError 

type InvalidEventUsageError struct {
	ast.Range
}

func (*InvalidEventUsageError) Error 

func (e *InvalidEventUsageError) Error() string

func (*InvalidEventUsageError) IsUserError 

func (*InvalidEventUsageError) IsUserError()

type InvalidFailableResourceDowncastOutsideOptionalBindingError 

type InvalidFailableResourceDowncastOutsideOptionalBindingError struct {
	ast.Range
}

func (*InvalidFailableResourceDowncastOutsideOptionalBindingError) Error 

func (e *InvalidFailableResourceDowncastOutsideOptionalBindingError) Error() string

func (*InvalidFailableResourceDowncastOutsideOptionalBindingError) IsUserError 

func (*InvalidFailableResourceDowncastOutsideOptionalBindingError) IsUserError()

type InvalidFixedPointLiteralRangeError 

type InvalidFixedPointLiteralRangeError struct {
	ExpectedType          Type
	ExpectedMinInt        *big.Int
	ExpectedMinFractional *big.Int
	ExpectedMaxInt        *big.Int
	ExpectedMaxFractional *big.Int
	ast.Range
}

func (*InvalidFixedPointLiteralRangeError) Error 

func (e *InvalidFixedPointLiteralRangeError) Error() string

func (*InvalidFixedPointLiteralRangeError) IsUserError 

func (*InvalidFixedPointLiteralRangeError) IsUserError()

func (*InvalidFixedPointLiteralRangeError) SecondaryError 

func (e *InvalidFixedPointLiteralRangeError) SecondaryError() string

type InvalidFixedPointLiteralScaleError 

type InvalidFixedPointLiteralScaleError struct {
	ExpectedType  Type
	ExpectedScale uint
	ast.Range
}

func (*InvalidFixedPointLiteralScaleError) Error 

func (e *InvalidFixedPointLiteralScaleError) Error() string

func (*InvalidFixedPointLiteralScaleError) IsUserError 

func (*InvalidFixedPointLiteralScaleError) IsUserError()

func (*InvalidFixedPointLiteralScaleError) SecondaryError 

func (e *InvalidFixedPointLiteralScaleError) SecondaryError() string

type InvalidImplementationError 

type InvalidImplementationError struct {
	ImplementedKind common.DeclarationKind
	ContainerKind   common.DeclarationKind
	Pos             ast.Position
}

func (*InvalidImplementationError) EndPosition 

func (e *InvalidImplementationError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidImplementationError) Error 

func (e *InvalidImplementationError) Error() string

func (*InvalidImplementationError) IsUserError 

func (*InvalidImplementationError) IsUserError()

func (*InvalidImplementationError) StartPosition 

func (e *InvalidImplementationError) StartPosition() ast.Position

type InvalidIntegerLiteralRangeError 

type InvalidIntegerLiteralRangeError struct {
	ExpectedType   Type
	ExpectedMinInt *big.Int
	ExpectedMaxInt *big.Int
	ast.Range
}

func (*InvalidIntegerLiteralRangeError) Error 

func (e *InvalidIntegerLiteralRangeError) Error() string

func (*InvalidIntegerLiteralRangeError) IsUserError 

func (*InvalidIntegerLiteralRangeError) IsUserError()

func (*InvalidIntegerLiteralRangeError) SecondaryError 

func (e *InvalidIntegerLiteralRangeError) SecondaryError() string

type InvalidInterfaceConditionResourceInvalidationError 

type InvalidInterfaceConditionResourceInvalidationError struct {
	ast.Range
}

func (*InvalidInterfaceConditionResourceInvalidationError) Error 

func (e *InvalidInterfaceConditionResourceInvalidationError) Error() string

func (*InvalidInterfaceConditionResourceInvalidationError) IsUserError 

func (*InvalidInterfaceConditionResourceInvalidationError) IsUserError()

type InvalidInterfaceDeclarationError 

type InvalidInterfaceDeclarationError struct {
	CompositeKind common.CompositeKind
	ast.Range
}

func (*InvalidInterfaceDeclarationError) Error 

func (e *InvalidInterfaceDeclarationError) Error() string

func (*InvalidInterfaceDeclarationError) IsUserError 

func (*InvalidInterfaceDeclarationError) IsUserError()

type InvalidInterfaceTypeError 

type InvalidInterfaceTypeError struct {
	ActualType   Type
	ExpectedType Type
	ast.Range
}

func (*InvalidInterfaceTypeError) Error 

func (e *InvalidInterfaceTypeError) Error() string

func (*InvalidInterfaceTypeError) IsUserError 

func (*InvalidInterfaceTypeError) IsUserError()

func (*InvalidInterfaceTypeError) SecondaryError 

func (e *InvalidInterfaceTypeError) SecondaryError() string

type InvalidIntersectedTypeError 

type InvalidIntersectedTypeError struct {
	Type Type
	ast.Range
}

func (*InvalidIntersectedTypeError) Error 

func (e *InvalidIntersectedTypeError) Error() string

func (*InvalidIntersectedTypeError) IsUserError 

func (*InvalidIntersectedTypeError) IsUserError()

type InvalidIntersectionTypeDuplicateError 

type InvalidIntersectionTypeDuplicateError struct {
	Type *InterfaceType
	ast.Range
}

func (*InvalidIntersectionTypeDuplicateError) Error 

func (e *InvalidIntersectionTypeDuplicateError) Error() string

func (*InvalidIntersectionTypeDuplicateError) IsUserError 

func (*InvalidIntersectionTypeDuplicateError) IsUserError()

type InvalidMappedAuthorizationOutsideOfFieldError 

type InvalidMappedAuthorizationOutsideOfFieldError struct {
	Map *EntitlementMapType
	ast.Range
}

InvalidMappedAuthorizationOutsideOfFieldError

func (*InvalidMappedAuthorizationOutsideOfFieldError) EndPosition 

func (e *InvalidMappedAuthorizationOutsideOfFieldError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidMappedAuthorizationOutsideOfFieldError) Error 

func (e *InvalidMappedAuthorizationOutsideOfFieldError) Error() string

func (*InvalidMappedAuthorizationOutsideOfFieldError) IsUserError 

func (*InvalidMappedAuthorizationOutsideOfFieldError) IsUserError()

func (*InvalidMappedAuthorizationOutsideOfFieldError) StartPosition 

func (e *InvalidMappedAuthorizationOutsideOfFieldError) StartPosition() ast.Position

type InvalidMappedEntitlementMemberError 

type InvalidMappedEntitlementMemberError struct {
	Pos ast.Position
}

InvalidMappedEntitlementMemberError

func (*InvalidMappedEntitlementMemberError) EndPosition 

func (e *InvalidMappedEntitlementMemberError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidMappedEntitlementMemberError) Error 

func (e *InvalidMappedEntitlementMemberError) Error() string

func (*InvalidMappedEntitlementMemberError) IsUserError 

func (*InvalidMappedEntitlementMemberError) IsUserError()

func (*InvalidMappedEntitlementMemberError) StartPosition 

func (e *InvalidMappedEntitlementMemberError) StartPosition() ast.Position

type InvalidMoveError 

type InvalidMoveError struct {
	Name            string
	DeclarationKind common.DeclarationKind
	Pos             ast.Position
}

func (*InvalidMoveError) EndPosition 

func (e *InvalidMoveError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*InvalidMoveError) Error 

func (e *InvalidMoveError) Error() string

func (*InvalidMoveError) IsUserError 

func (*InvalidMoveError) IsUserError()

func (*InvalidMoveError) StartPosition 

func (e *InvalidMoveError) StartPosition() ast.Position

type InvalidMoveOperationError 

type InvalidMoveOperationError struct {
	ast.Range
}

func (*InvalidMoveOperationError) Error 

func (e *InvalidMoveOperationError) Error() string

func (*InvalidMoveOperationError) IsUserError 

func (*InvalidMoveOperationError) IsUserError()

func (*InvalidMoveOperationError) SecondaryError 

func (e *InvalidMoveOperationError) SecondaryError() string

type InvalidNameError 

type InvalidNameError struct {
	Name string
	Pos  ast.Position
}

func (*InvalidNameError) EndPosition 

func (e *InvalidNameError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*InvalidNameError) Error 

func (e *InvalidNameError) Error() string

func (*InvalidNameError) IsUserError 

func (*InvalidNameError) IsUserError()

func (*InvalidNameError) StartPosition 

func (e *InvalidNameError) StartPosition() ast.Position

type InvalidNativeModifierError 

type InvalidNativeModifierError struct {
	ast.Range
}

func (*InvalidNativeModifierError) Error 

func (e *InvalidNativeModifierError) Error() string

func (*InvalidNativeModifierError) IsUserError 

func (*InvalidNativeModifierError) IsUserError()

type InvalidNestedDeclarationError 

type InvalidNestedDeclarationError struct {
	NestedDeclarationKind    common.DeclarationKind
	ContainerDeclarationKind common.DeclarationKind
	ast.Range
}

func (*InvalidNestedDeclarationError) Error 

func (e *InvalidNestedDeclarationError) Error() string

func (*InvalidNestedDeclarationError) IsUserError 

func (*InvalidNestedDeclarationError) IsUserError()

type InvalidNestedResourceMoveError 

type InvalidNestedResourceMoveError struct {
	ast.Range
}

func (*InvalidNestedResourceMoveError) Error 

func (e *InvalidNestedResourceMoveError) Error() string

func (*InvalidNestedResourceMoveError) IsUserError 

func (*InvalidNestedResourceMoveError) IsUserError()

type InvalidNestedTypeError 

type InvalidNestedTypeError struct {
	Type *ast.NominalType
}

func (*InvalidNestedTypeError) EndPosition 

func (e *InvalidNestedTypeError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*InvalidNestedTypeError) Error 

func (e *InvalidNestedTypeError) Error() string

func (*InvalidNestedTypeError) IsUserError 

func (*InvalidNestedTypeError) IsUserError()

func (*InvalidNestedTypeError) StartPosition 

func (e *InvalidNestedTypeError) StartPosition() ast.Position

type InvalidNilCoalescingRightResourceOperandError 

type InvalidNilCoalescingRightResourceOperandError struct {
	ast.Range
}

func (*InvalidNilCoalescingRightResourceOperandError) Error 

func (e *InvalidNilCoalescingRightResourceOperandError) Error() string

type InvalidNonEntitlementAccessError 

type InvalidNonEntitlementAccessError struct {
	ast.Range
}

InvalidNonEntitlementAccessError

func (*InvalidNonEntitlementAccessError) Error 

func (e *InvalidNonEntitlementAccessError) Error() string

func (*InvalidNonEntitlementAccessError) IsUserError 

func (*InvalidNonEntitlementAccessError) IsUserError()

type InvalidNonEntitlementTypeInMapError 

type InvalidNonEntitlementTypeInMapError struct {
	Pos ast.Position
}

InvalidNonEntitlementTypeInMapError

func (*InvalidNonEntitlementTypeInMapError) EndPosition 

func (e *InvalidNonEntitlementTypeInMapError) EndPosition(common.MemoryGauge) ast.Position

func (*InvalidNonEntitlementTypeInMapError) Error 

func (e *InvalidNonEntitlementTypeInMapError) Error() string

func (*InvalidNonEntitlementTypeInMapError) IsUserError 

func (*InvalidNonEntitlementTypeInMapError) IsUserError()

func (*InvalidNonEntitlementTypeInMapError) StartPosition 

func (e *InvalidNonEntitlementTypeInMapError) StartPosition() ast.Position

type InvalidNonEnumCaseError 

type InvalidNonEnumCaseError struct {
	ContainerDeclarationKind common.DeclarationKind
	ast.Range
}

func (*InvalidNonEnumCaseError) Error 

func (e *InvalidNonEnumCaseError) Error() string

func (*InvalidNonEnumCaseError) IsUserError 

func (*InvalidNonEnumCaseError) IsUserError()

type InvalidNonIdentifierFailableResourceDowncast 

type InvalidNonIdentifierFailableResourceDowncast struct {
	ast.Range
}

func (*InvalidNonIdentifierFailableResourceDowncast) Error 

func (e *InvalidNonIdentifierFailableResourceDowncast) Error() string

func (*InvalidNonIdentifierFailableResourceDowncast) IsUserError 

func (*InvalidNonIdentifierFailableResourceDowncast) IsUserError()

func (*InvalidNonIdentifierFailableResourceDowncast) SecondaryError 

func (e *InvalidNonIdentifierFailableResourceDowncast) SecondaryError() string

type InvalidNonImportableTransactionParameterTypeError 

type InvalidNonImportableTransactionParameterTypeError struct {
	Type Type
	ast.Range
}

func (*InvalidNonImportableTransactionParameterTypeError) Error 

func (e *InvalidNonImportableTransactionParameterTypeError) Error() string

func (*InvalidNonImportableTransactionParameterTypeError) IsUserError 

func (*InvalidNonImportableTransactionParameterTypeError) IsUserError()

type InvalidOptionalChainingError 

type InvalidOptionalChainingError struct {
	Type Type
	ast.Range
}

func (*InvalidOptionalChainingError) Error 

func (e *InvalidOptionalChainingError) Error() string

func (*InvalidOptionalChainingError) IsUserError 

func (*InvalidOptionalChainingError) IsUserError()

type InvalidPathDomainError 

type InvalidPathDomainError struct {
	ActualDomain string
	ast.Range
}

func (*InvalidPathDomainError) Error 

func (e *InvalidPathDomainError) Error() string

func (*InvalidPathDomainError) IsUserError 

func (*InvalidPathDomainError) IsUserError()

func (*InvalidPathDomainError) SecondaryError 

func (e *InvalidPathDomainError) SecondaryError() string

type InvalidPathIdentifierError 

type InvalidPathIdentifierError struct {
	ActualIdentifier string
	ast.Range
}

func (*InvalidPathIdentifierError) Error 

func (e *InvalidPathIdentifierError) Error() string

type InvalidPragmaError 

type InvalidPragmaError struct {
	Message string
	ast.Range
}

func (*InvalidPragmaError) Error 

func (e *InvalidPragmaError) Error() string

func (*InvalidPragmaError) IsUserError 

func (*InvalidPragmaError) IsUserError()

func (*InvalidPragmaError) SecondaryError 

func (e *InvalidPragmaError) SecondaryError() string

type InvalidResourceAnnotationError 

type InvalidResourceAnnotationError struct {
	ast.Range
}

func (*InvalidResourceAnnotationError) Error 

func (e *InvalidResourceAnnotationError) Error() string

func (*InvalidResourceAnnotationError) IsUserError 

func (*InvalidResourceAnnotationError) IsUserError()

type InvalidResourceArrayMemberError 

type InvalidResourceArrayMemberError struct {
	Name            string
	DeclarationKind common.DeclarationKind
	ast.Range
}

func (*InvalidResourceArrayMemberError) Error 

func (e *InvalidResourceArrayMemberError) Error() string

func (*InvalidResourceArrayMemberError) IsUserError 

func (*InvalidResourceArrayMemberError) IsUserError()

type InvalidResourceAssignmentError 

type InvalidResourceAssignmentError struct {
	ast.Range
}

func (*InvalidResourceAssignmentError) Error 

func (e *InvalidResourceAssignmentError) Error() string

func (*InvalidResourceAssignmentError) IsUserError 

func (*InvalidResourceAssignmentError) IsUserError()

func (*InvalidResourceAssignmentError) SecondaryError 

func (e *InvalidResourceAssignmentError) SecondaryError() string

type InvalidResourceCreationError 

type InvalidResourceCreationError struct {
	Type Type
	ast.Range
}

func (*InvalidResourceCreationError) Error 

func (e *InvalidResourceCreationError) Error() string

func (*InvalidResourceCreationError) IsUserError 

func (*InvalidResourceCreationError) IsUserError()

type InvalidResourceDictionaryMemberError 

type InvalidResourceDictionaryMemberError struct {
	Name            string
	DeclarationKind common.DeclarationKind
	ast.Range
}

func (*InvalidResourceDictionaryMemberError) Error 

func (e *InvalidResourceDictionaryMemberError) Error() string

func (*InvalidResourceDictionaryMemberError) IsUserError 

func (*InvalidResourceDictionaryMemberError) IsUserError()

type InvalidResourceFieldError 

type InvalidResourceFieldError struct {
	Name          string
	CompositeKind common.CompositeKind
	Pos           ast.Position
}

func (*InvalidResourceFieldError) EndPosition 

func (e *InvalidResourceFieldError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*InvalidResourceFieldError) Error 

func (e *InvalidResourceFieldError) Error() string

func (*InvalidResourceFieldError) IsUserError 

func (*InvalidResourceFieldError) IsUserError()

func (*InvalidResourceFieldError) StartPosition 

func (e *InvalidResourceFieldError) StartPosition() ast.Position

type InvalidResourceOptionalMemberError 

type InvalidResourceOptionalMemberError struct {
	Name            string
	DeclarationKind common.DeclarationKind
	ast.Range
}

func (*InvalidResourceOptionalMemberError) Error 

func (e *InvalidResourceOptionalMemberError) Error() string

func (*InvalidResourceOptionalMemberError) IsUserError 

func (*InvalidResourceOptionalMemberError) IsUserError()

type InvalidResourceTransactionParameterError 

type InvalidResourceTransactionParameterError struct {
	Type Type
	ast.Range
}

func (*InvalidResourceTransactionParameterError) Error 

func (e *InvalidResourceTransactionParameterError) Error() string

func (*InvalidResourceTransactionParameterError) IsUserError 

func (*InvalidResourceTransactionParameterError) IsUserError()

type InvalidSelfInvalidationError 

type InvalidSelfInvalidationError struct {
	InvalidationKind ResourceInvalidationKind
	ast.Range
}

func (*InvalidSelfInvalidationError) Error 

func (e *InvalidSelfInvalidationError) Error() string

func (*InvalidSelfInvalidationError) IsUserError 

func (*InvalidSelfInvalidationError) IsUserError()

type InvalidStaticModifierError 

type InvalidStaticModifierError struct {
	ast.Range
}

func (*InvalidStaticModifierError) Error 

func (e *InvalidStaticModifierError) Error() string

func (*InvalidStaticModifierError) IsUserError 

func (*InvalidStaticModifierError) IsUserError()

type InvalidSwapExpressionError 

type InvalidSwapExpressionError struct {
	Side common.OperandSide
	ast.Range
}

func (*InvalidSwapExpressionError) Error 

func (e *InvalidSwapExpressionError) Error() string

func (*InvalidSwapExpressionError) IsUserError 

func (*InvalidSwapExpressionError) IsUserError()

func (*InvalidSwapExpressionError) SecondaryError 

func (e *InvalidSwapExpressionError) SecondaryError() string

type InvalidTopLevelDeclarationError 

type InvalidTopLevelDeclarationError struct {
	DeclarationKind common.DeclarationKind
	ast.Range
}

func (*InvalidTopLevelDeclarationError) Error 

func (e *InvalidTopLevelDeclarationError) Error() string

func (*InvalidTopLevelDeclarationError) IsUserError 

func (*InvalidTopLevelDeclarationError) IsUserError()

type InvalidTransactionBlockError 

type InvalidTransactionBlockError struct {
	Name string
	Pos  ast.Position
}

func (*InvalidTransactionBlockError) EndPosition 

func (e *InvalidTransactionBlockError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*InvalidTransactionBlockError) Error 

func (e *InvalidTransactionBlockError) Error() string

func (*InvalidTransactionBlockError) IsUserError 

func (*InvalidTransactionBlockError) IsUserError()

func (*InvalidTransactionBlockError) SecondaryError 

func (e *InvalidTransactionBlockError) SecondaryError() string

func (*InvalidTransactionBlockError) StartPosition 

func (e *InvalidTransactionBlockError) StartPosition() ast.Position

type InvalidTransactionFieldAccessModifierError 

type InvalidTransactionFieldAccessModifierError struct {
	Name   string
	Access ast.Access
	Pos    ast.Position
}

func (*InvalidTransactionFieldAccessModifierError) EndPosition 

func (e *InvalidTransactionFieldAccessModifierError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*InvalidTransactionFieldAccessModifierError) Error 

func (e *InvalidTransactionFieldAccessModifierError) Error() string

func (*InvalidTransactionFieldAccessModifierError) IsUserError 

func (*InvalidTransactionFieldAccessModifierError) IsUserError()

func (*InvalidTransactionFieldAccessModifierError) StartPosition 

func (e *InvalidTransactionFieldAccessModifierError) StartPosition() ast.Position

type InvalidTransactionPrepareParameterTypeError 

type InvalidTransactionPrepareParameterTypeError struct {
	Type Type
	ast.Range
}

func (*InvalidTransactionPrepareParameterTypeError) Error 

func (e *InvalidTransactionPrepareParameterTypeError) Error() string

func (*InvalidTransactionPrepareParameterTypeError) IsUserError 

func (*InvalidTransactionPrepareParameterTypeError) IsUserError()

type InvalidTypeArgumentCountError 

type InvalidTypeArgumentCountError struct {
	TypeParameterCount int
	TypeArgumentCount  int
	ast.Range
}

func (*InvalidTypeArgumentCountError) Error 

func (e *InvalidTypeArgumentCountError) Error() string

func (*InvalidTypeArgumentCountError) IsUserError 

func (*InvalidTypeArgumentCountError) IsUserError()

func (*InvalidTypeArgumentCountError) SecondaryError 

func (e *InvalidTypeArgumentCountError) SecondaryError() string

type InvalidTypeArgumentError 

type InvalidTypeArgumentError struct {
	TypeArgumentName string
	Details          string
	ast.Range
}

func (*InvalidTypeArgumentError) Error 

func (e *InvalidTypeArgumentError) Error() string

func (*InvalidTypeArgumentError) IsUserError 

func (*InvalidTypeArgumentError) IsUserError()

func (*InvalidTypeArgumentError) SecondaryError 

func (e *InvalidTypeArgumentError) SecondaryError() string

type InvalidTypeIndexingError 

type InvalidTypeIndexingError struct {
	IndexingExpression ast.Expression
	BaseType           Type
	ast.Range
}

InvalidTypeIndexingError

func (*InvalidTypeIndexingError) Error 

func (e *InvalidTypeIndexingError) Error() string

func (*InvalidTypeIndexingError) IsUserError 

func (*InvalidTypeIndexingError) IsUserError()

type InvalidTypeParameterizedNonNativeFunctionError 

type InvalidTypeParameterizedNonNativeFunctionError struct {
	ast.Range
}

func (*InvalidTypeParameterizedNonNativeFunctionError) Error 

func (e *InvalidTypeParameterizedNonNativeFunctionError) Error() string

func (*InvalidTypeParameterizedNonNativeFunctionError) IsUserError 

func (*InvalidTypeParameterizedNonNativeFunctionError) IsUserError()

type InvalidUnaryOperandError 

type InvalidUnaryOperandError struct {
	ExpectedType            Type
	ExpectedTypeDescription string
	ActualType              Type
	ast.Range
	Operation ast.Operation
}

func (*InvalidUnaryOperandError) Error 

func (e *InvalidUnaryOperandError) Error() string

func (*InvalidUnaryOperandError) IsUserError 

func (*InvalidUnaryOperandError) IsUserError()

func (*InvalidUnaryOperandError) SecondaryError 

func (e *InvalidUnaryOperandError) SecondaryError() string

type InvalidVariableKindError 

type InvalidVariableKindError struct {
	Kind ast.VariableKind
	ast.Range
}

func (*InvalidVariableKindError) Error 

func (e *InvalidVariableKindError) Error() string

func (*InvalidVariableKindError) IsUserError 

func (*InvalidVariableKindError) IsUserError()

type InvalidatedResourceReferenceError 

type InvalidatedResourceReferenceError struct {
	Invalidation ResourceInvalidation
	ast.Range
}

func (*InvalidatedResourceReferenceError) Error 

func (e *InvalidatedResourceReferenceError) Error() string

func (*InvalidatedResourceReferenceError) ErrorNotes 

func (e *InvalidatedResourceReferenceError) ErrorNotes() []errors.ErrorNote

func (*InvalidatedResourceReferenceError) IsUserError 

func (*InvalidatedResourceReferenceError) IsUserError()

type InvocationExpressionTypes 

type InvocationExpressionTypes struct {
	ReturnType         Type
	TypeArguments      *TypeParameterTypeOrderedMap
	ArgumentTypes      []Type
	TypeParameterTypes []Type
}

type InvocationTypeInferenceError added in v1.3.0 

type InvocationTypeInferenceError struct {
	ast.Range
}

func (*InvocationTypeInferenceError) Error added in v1.3.0 

func (e *InvocationTypeInferenceError) Error() string

func (*InvocationTypeInferenceError) IsUserError added in v1.3.0 

func (*InvocationTypeInferenceError) IsUserError()

type LocatedType 

type LocatedType interface {
	Type
	GetLocation() common.Location
}

LocatedType is a type which has a location

type LocationHandlerFunc 

type LocationHandlerFunc func(identifiers []ast.Identifier, location common.Location) ([]ResolvedLocation, error)

func AddressLocationHandlerFunc 

func AddressLocationHandlerFunc(resolveAddressContractNames AddressContractNamesResolver) LocationHandlerFunc

AddressLocationHandlerFunc returns a location handler which returns a single location for non-address locations, and uses the given address contract names resolve function to get all contract names for an address

type MappingAccessMissingKeywordError 

type MappingAccessMissingKeywordError struct {
	Type Type
	ast.Range
}

MappingAccessMissingKeywordError

func (*MappingAccessMissingKeywordError) Error 

func (e *MappingAccessMissingKeywordError) Error() string

func (*MappingAccessMissingKeywordError) IsUserError 

func (*MappingAccessMissingKeywordError) IsUserError()

func (*MappingAccessMissingKeywordError) SecondaryError 

func (e *MappingAccessMissingKeywordError) SecondaryError() string

type Member 

type Member struct {
	TypeAnnotation TypeAnnotation
	// Parent type where this member can be resolved
	ContainerType  Type
	DocString      string
	ArgumentLabels []string
	Identifier     ast.Identifier
	Access         Access
	// TODO: replace with dedicated MemberKind enum
	DeclarationKind common.DeclarationKind
	VariableKind    ast.VariableKind
	// Predeclared fields can be considered initialized
	Predeclared       bool
	HasImplementation bool
	HasConditions     bool
	// IgnoreInSerialization determines if the field is ignored in serialization
	IgnoreInSerialization bool
}

func NewConstructorMember 

func NewConstructorMember(
	memoryGauge common.MemoryGauge,
	containerType Type,
	access Access,
	identifier string,
	functionType *FunctionType,
	docString string,
) *Member

func NewFieldMember 

func NewFieldMember(
	memoryGauge common.MemoryGauge,
	containerType Type,
	access Access,
	variableKind ast.VariableKind,
	identifier string,
	fieldType Type,
	docString string,
) *Member

func NewFunctionMember 

func NewFunctionMember(
	memoryGauge common.MemoryGauge,
	containerType Type,
	access Access,
	identifier string,
	functionType *FunctionType,
	docString string,
) *Member

func NewPublicConstantFieldMember 

func NewPublicConstantFieldMember(
	memoryGauge common.MemoryGauge,
	containerType Type,
	identifier string,
	fieldType Type,
	docString string,
) *Member

func NewPublicFunctionMember 

func NewPublicFunctionMember(
	memoryGauge common.MemoryGauge,
	containerType Type,
	identifier string,
	functionType *FunctionType,
	docString string,
) *Member

func NewUnmeteredConstructorMember 

func NewUnmeteredConstructorMember(
	containerType Type,
	access Access,
	identifier string,
	functionType *FunctionType,
	docString string,
) *Member

func NewUnmeteredFieldMember 

func NewUnmeteredFieldMember(
	containerType Type,
	access Access,
	variableKind ast.VariableKind,
	identifier string,
	fieldType Type,
	docString string,
) *Member

func NewUnmeteredFunctionMember 

func NewUnmeteredFunctionMember(
	containerType Type,
	access Access,
	identifier string,
	functionType *FunctionType,
	docString string,
) *Member

func NewUnmeteredPublicConstantFieldMember 

func NewUnmeteredPublicConstantFieldMember(
	containerType Type,
	identifier string,
	fieldType Type,
	docString string,
) *Member

func NewUnmeteredPublicFunctionMember 

func NewUnmeteredPublicFunctionMember(
	containerType Type,
	identifier string,
	functionType *FunctionType,
	docString string,
) *Member

func (*Member) IsExportable 

func (m *Member) IsExportable(results map[*Member]bool) (result bool)

IsExportable returns whether a member is exportable

func (*Member) IsImportable 

func (m *Member) IsImportable(results map[*Member]bool) (result bool)

IsImportable returns whether a member can be imported to a program

func (*Member) IsStorable 

func (m *Member) IsStorable(results map[*Member]bool) (result bool)

IsStorable returns whether a member is a storable field

func (*Member) IsValidEventParameterType 

func (m *Member) IsValidEventParameterType(results map[*Member]bool) bool

IsValidEventParameterType returns whether has a valid event parameter type

type MemberAccess 

type MemberAccess struct {
	AccessedType Type
	StartPos     Position
	EndPos       Position
}

type MemberAccessInfo 

type MemberAccessInfo struct {
	AccessedType    Type
	ResultingType   Type
	Member          *Member
	IsOptional      bool
	ReturnReference bool
}

type MemberAccesses 

type MemberAccesses struct {
	// contains filtered or unexported fields
}

func NewMemberAccesses 

func NewMemberAccesses() *MemberAccesses

func (*MemberAccesses) All 

func (m *MemberAccesses) All() []MemberAccess

func (*MemberAccesses) Find 

func (m *MemberAccesses) Find(pos Position) *MemberAccess

func (*MemberAccesses) Put 

func (m *MemberAccesses) Put(startPos, endPos ast.Position, accessedType Type)

type MemberAccountAccessHandlerFunc 

type MemberAccountAccessHandlerFunc func(checker *Checker, memberLocation common.Location) bool

type MemberFieldDeclarationOrderedMap 

type MemberFieldDeclarationOrderedMap = orderedmap.OrderedMap[*Member, *ast.FieldDeclaration]

type MemberMismatch 

type MemberMismatch struct {
	CompositeMember *Member
	InterfaceMember *Member
}

type MemberMismatchNote 

type MemberMismatchNote struct {
	ast.Range
}

func (MemberMismatchNote) Message 

func (n MemberMismatchNote) Message() string

type MemberResolver 

type MemberResolver struct {
	Resolve func(
		memoryGauge common.MemoryGauge,
		identifier string,
		targetRange ast.HasPosition,
		report func(error),
	) *Member
	Kind common.DeclarationKind
}

type MissingAccessModifierError 

type MissingAccessModifierError struct {
	Explanation     string
	Pos             ast.Position
	DeclarationKind common.DeclarationKind
}

func (*MissingAccessModifierError) EndPosition 

func (e *MissingAccessModifierError) EndPosition(common.MemoryGauge) ast.Position

func (*MissingAccessModifierError) Error 

func (e *MissingAccessModifierError) Error() string

func (*MissingAccessModifierError) IsUserError 

func (*MissingAccessModifierError) IsUserError()

func (*MissingAccessModifierError) StartPosition 

func (e *MissingAccessModifierError) StartPosition() ast.Position

type MissingArgumentLabelError 

type MissingArgumentLabelError struct {
	ExpectedArgumentLabel string
	ast.Range
}

func (*MissingArgumentLabelError) Error 

func (e *MissingArgumentLabelError) Error() string

func (*MissingArgumentLabelError) IsUserError 

func (*MissingArgumentLabelError) IsUserError()

func (*MissingArgumentLabelError) SuggestFixes 

func (e *MissingArgumentLabelError) SuggestFixes(_ string) []errors.SuggestedFix[ast.TextEdit]

type MissingConformanceError 

type MissingConformanceError struct {
	CompositeType *CompositeType
	InterfaceType *InterfaceType
	ast.Range
}

MissingConformanceError

func (*MissingConformanceError) Error 

func (e *MissingConformanceError) Error() string

func (*MissingConformanceError) IsUserError 

func (*MissingConformanceError) IsUserError()

type MissingCreateError 

type MissingCreateError struct {
	ast.Range
}

func (*MissingCreateError) Error 

func (e *MissingCreateError) Error() string

func (*MissingCreateError) IsUserError 

func (*MissingCreateError) IsUserError()

func (*MissingCreateError) SecondaryError 

func (e *MissingCreateError) SecondaryError() string

type MissingEntryPointError 

type MissingEntryPointError struct {
	Expected string
}

func (*MissingEntryPointError) Error 

func (e *MissingEntryPointError) Error() string

func (*MissingEntryPointError) IsUserError 

func (*MissingEntryPointError) IsUserError()

type MissingEnumRawTypeError 

type MissingEnumRawTypeError struct {
	Pos ast.Position
}

func (*MissingEnumRawTypeError) EndPosition 

func (e *MissingEnumRawTypeError) EndPosition(common.MemoryGauge) ast.Position

func (*MissingEnumRawTypeError) Error 

func (e *MissingEnumRawTypeError) Error() string

func (*MissingEnumRawTypeError) IsUserError 

func (*MissingEnumRawTypeError) IsUserError()

func (*MissingEnumRawTypeError) StartPosition 

func (e *MissingEnumRawTypeError) StartPosition() ast.Position

type MissingFunctionBodyError 

type MissingFunctionBodyError struct {
	Pos ast.Position
}

func (*MissingFunctionBodyError) EndPosition 

func (e *MissingFunctionBodyError) EndPosition(common.MemoryGauge) ast.Position

func (*MissingFunctionBodyError) Error 

func (e *MissingFunctionBodyError) Error() string

func (*MissingFunctionBodyError) IsUserError 

func (*MissingFunctionBodyError) IsUserError()

func (*MissingFunctionBodyError) StartPosition 

func (e *MissingFunctionBodyError) StartPosition() ast.Position

type MissingInitializerError 

type MissingInitializerError struct {
	ContainerType  Type
	FirstFieldName string
	FirstFieldPos  ast.Position
}

func (*MissingInitializerError) EndPosition 

func (e *MissingInitializerError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*MissingInitializerError) Error 

func (e *MissingInitializerError) Error() string

func (*MissingInitializerError) IsUserError 

func (*MissingInitializerError) IsUserError()

func (*MissingInitializerError) StartPosition 

func (e *MissingInitializerError) StartPosition() ast.Position

type MissingMoveOperationError 

type MissingMoveOperationError struct {
	Pos ast.Position
}

func (*MissingMoveOperationError) EndPosition 

func (e *MissingMoveOperationError) EndPosition(common.MemoryGauge) ast.Position

func (*MissingMoveOperationError) Error 

func (e *MissingMoveOperationError) Error() string

func (*MissingMoveOperationError) IsUserError 

func (*MissingMoveOperationError) IsUserError()

func (*MissingMoveOperationError) StartPosition 

func (e *MissingMoveOperationError) StartPosition() ast.Position

type MissingResourceAnnotationError 

type MissingResourceAnnotationError struct {
	ast.Range
}

func (*MissingResourceAnnotationError) Error 

func (e *MissingResourceAnnotationError) Error() string

func (*MissingResourceAnnotationError) IsUserError 

func (*MissingResourceAnnotationError) IsUserError()

type MissingReturnStatementError 

type MissingReturnStatementError struct {
	ast.Range
}

func (*MissingReturnStatementError) Error 

func (e *MissingReturnStatementError) Error() string

func (*MissingReturnStatementError) IsUserError 

func (*MissingReturnStatementError) IsUserError()

type MissingReturnValueError 

type MissingReturnValueError struct {
	ExpectedValueType Type
	ast.Range
}

func (*MissingReturnValueError) Error 

func (e *MissingReturnValueError) Error() string

func (*MissingReturnValueError) IsUserError 

func (*MissingReturnValueError) IsUserError()

type MissingSwitchCaseStatementsError 

type MissingSwitchCaseStatementsError struct {
	Pos ast.Position
}

func (*MissingSwitchCaseStatementsError) EndPosition 

func (e *MissingSwitchCaseStatementsError) EndPosition(common.MemoryGauge) ast.Position

func (*MissingSwitchCaseStatementsError) Error 

func (e *MissingSwitchCaseStatementsError) Error() string

func (*MissingSwitchCaseStatementsError) IsUserError 

func (*MissingSwitchCaseStatementsError) IsUserError()

func (*MissingSwitchCaseStatementsError) StartPosition 

func (e *MissingSwitchCaseStatementsError) StartPosition() ast.Position

type MissingTypeArgumentError 

type MissingTypeArgumentError struct {
	TypeArgumentName string
	ast.Range
}

func (*MissingTypeArgumentError) Error 

func (e *MissingTypeArgumentError) Error() string

func (*MissingTypeArgumentError) IsUserError 

func (*MissingTypeArgumentError) IsUserError()

type MultipleInterfaceDefaultImplementationsError 

type MultipleInterfaceDefaultImplementationsError struct {
	CompositeKindedType CompositeKindedType
	Member              *Member
	ast.Range
}

MultipleInterfaceDefaultImplementationsError

func (*MultipleInterfaceDefaultImplementationsError) Error 

func (e *MultipleInterfaceDefaultImplementationsError) Error() string

func (*MultipleInterfaceDefaultImplementationsError) IsUserError 

func (*MultipleInterfaceDefaultImplementationsError) IsUserError()

type NativeFunctionWithImplementationError 

type NativeFunctionWithImplementationError struct {
	ast.Range
}

func (*NativeFunctionWithImplementationError) Error 

func (e *NativeFunctionWithImplementationError) Error() string

func (*NativeFunctionWithImplementationError) IsUserError 

func (*NativeFunctionWithImplementationError) IsUserError()

type NestedReferenceError 

type NestedReferenceError struct {
	Type *ReferenceType
	ast.Range
}

NestedReferenceError

func (*NestedReferenceError) Error 

func (e *NestedReferenceError) Error() string

func (*NestedReferenceError) IsUserError 

func (*NestedReferenceError) IsUserError()

type NominalType 

type NominalType interface {
	Type
	MemberMap() *StringMemberOrderedMap
}

supertype of interfaces and composites

type NonReferenceTypeReferenceError 

type NonReferenceTypeReferenceError struct {
	ActualType Type
	ast.Range
}

func (*NonReferenceTypeReferenceError) Error 

func (e *NonReferenceTypeReferenceError) Error() string

func (*NonReferenceTypeReferenceError) IsUserError 

func (*NonReferenceTypeReferenceError) IsUserError()

func (*NonReferenceTypeReferenceError) SecondaryError 

func (e *NonReferenceTypeReferenceError) SecondaryError() string

type NonResourceTypeError 

type NonResourceTypeError struct {
	ActualType Type
	ast.Range
}

func (*NonResourceTypeError) Error 

func (e *NonResourceTypeError) Error() string

func (*NonResourceTypeError) IsUserError 

func (*NonResourceTypeError) IsUserError()

func (*NonResourceTypeError) SecondaryError 

func (e *NonResourceTypeError) SecondaryError() string

type NotCallableError 

type NotCallableError struct {
	Type Type
	ast.Range
}

func (*NotCallableError) Error 

func (e *NotCallableError) Error() string

func (*NotCallableError) IsUserError 

func (*NotCallableError) IsUserError()

type NotDeclaredError 

type NotDeclaredError struct {
	Expression   *ast.IdentifierExpression
	Name         string
	Pos          ast.Position
	ExpectedKind common.DeclarationKind
}

func (*NotDeclaredError) EndPosition 

func (e *NotDeclaredError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*NotDeclaredError) Error 

func (e *NotDeclaredError) Error() string

func (*NotDeclaredError) IsUserError 

func (*NotDeclaredError) IsUserError()

func (*NotDeclaredError) SecondaryError 

func (e *NotDeclaredError) SecondaryError() string

func (*NotDeclaredError) StartPosition 

func (e *NotDeclaredError) StartPosition() ast.Position

type NotDeclaredMemberError 

type NotDeclaredMemberError struct {
	Type       Type
	Expression *ast.MemberExpression
	Name       string
	ast.Range
	// contains filtered or unexported fields
}

func (*NotDeclaredMemberError) Error 

func (e *NotDeclaredMemberError) Error() string

func (*NotDeclaredMemberError) IsUserError 

func (*NotDeclaredMemberError) IsUserError()

func (*NotDeclaredMemberError) SecondaryError 

func (e *NotDeclaredMemberError) SecondaryError() string

func (*NotDeclaredMemberError) SuggestFixes 

func (e *NotDeclaredMemberError) SuggestFixes(_ string) []errors.SuggestedFix[ast.TextEdit]

type NotEquatableTypeError 

type NotEquatableTypeError struct {
	Type Type
	ast.Range
}

func (*NotEquatableTypeError) Error 

func (e *NotEquatableTypeError) Error() string

func (*NotEquatableTypeError) IsUserError 

func (*NotEquatableTypeError) IsUserError()

type NotExportedError 

type NotExportedError struct {
	Name           string
	ImportLocation common.Location
	Available      []string
	Pos            ast.Position
}

func (*NotExportedError) EndPosition 

func (e *NotExportedError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*NotExportedError) Error 

func (e *NotExportedError) Error() string

func (*NotExportedError) IsUserError 

func (*NotExportedError) IsUserError()

func (*NotExportedError) SecondaryError 

func (e *NotExportedError) SecondaryError() string

func (*NotExportedError) StartPosition 

func (e *NotExportedError) StartPosition() ast.Position

type NotIndexableTypeError 

type NotIndexableTypeError struct {
	Type Type
	ast.Range
}

func (*NotIndexableTypeError) Error 

func (e *NotIndexableTypeError) Error() string

func (*NotIndexableTypeError) IsUserError 

func (*NotIndexableTypeError) IsUserError()

type NotIndexingAssignableTypeError 

type NotIndexingAssignableTypeError struct {
	Type Type
	ast.Range
}

func (*NotIndexingAssignableTypeError) Error 

func (e *NotIndexingAssignableTypeError) Error() string

func (*NotIndexingAssignableTypeError) IsUserError 

func (*NotIndexingAssignableTypeError) IsUserError()

type NumberConversionArgumentTypes 

type NumberConversionArgumentTypes struct {
	Type  Type
	Range ast.Range
}

type NumericType 

type NumericType struct {
	// contains filtered or unexported fields
}

NumericType represent all the types in the integer range and non-fractional ranged types.

func NewNumericType 

func NewNumericType(typeName string) *NumericType

func (*NumericType) AsSuperType 

func (t *NumericType) AsSuperType() *NumericType

func (*NumericType) ByteSize 

func (t *NumericType) ByteSize() int

func (*NumericType) CheckInstantiated 

func (*NumericType) CheckInstantiated(_ ast.HasPosition, _ common.MemoryGauge, _ func(err error))

func (*NumericType) ContainFieldsOrElements 

func (t *NumericType) ContainFieldsOrElements() bool

func (*NumericType) EffectiveInterfaceConformanceSet added in v1.3.0 

func (t *NumericType) EffectiveInterfaceConformanceSet() *InterfaceSet

func (*NumericType) Equal 

func (t *NumericType) Equal(other Type) bool

func (*NumericType) GetMembers 

func (t *NumericType) GetMembers() map[string]MemberResolver

func (*NumericType) ID 

func (t *NumericType) ID() TypeID

func (*NumericType) IsComparable 

func (t *NumericType) IsComparable() bool

func (*NumericType) IsEquatable 

func (*NumericType) IsEquatable() bool

func (*NumericType) IsExportable 

func (*NumericType) IsExportable(_ map[*Member]bool) bool

func (*NumericType) IsImportable 

func (t *NumericType) IsImportable(_ map[*Member]bool) bool

func (*NumericType) IsInvalidType 

func (*NumericType) IsInvalidType() bool

func (*NumericType) IsOrContainsReferenceType 

func (*NumericType) IsOrContainsReferenceType() bool

func (*NumericType) IsPrimitiveType 

func (*NumericType) IsPrimitiveType() bool

func (*NumericType) IsResourceType 

func (*NumericType) IsResourceType() bool

func (*NumericType) IsStorable 

func (*NumericType) IsStorable(_ map[*Member]bool) bool

func (*NumericType) IsSuperType 

func (t *NumericType) IsSuperType() bool

func (*NumericType) IsType 

func (*NumericType) IsType()

func (*NumericType) Map 

func (t *NumericType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*NumericType) MaxInt 

func (t *NumericType) MaxInt() *big.Int

func (*NumericType) MinInt 

func (t *NumericType) MinInt() *big.Int

func (*NumericType) QualifiedString 

func (t *NumericType) QualifiedString() string

func (*NumericType) Resolve 

func (t *NumericType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*NumericType) RewriteWithIntersectionTypes 

func (t *NumericType) RewriteWithIntersectionTypes() (result Type, rewritten bool)

func (*NumericType) String 

func (t *NumericType) String() string

func (*NumericType) SupportsSaturatingAdd 

func (t *NumericType) SupportsSaturatingAdd() bool

func (*NumericType) SupportsSaturatingDivide 

func (t *NumericType) SupportsSaturatingDivide() bool

func (*NumericType) SupportsSaturatingMultiply 

func (t *NumericType) SupportsSaturatingMultiply() bool

func (*NumericType) SupportsSaturatingSubtract 

func (t *NumericType) SupportsSaturatingSubtract() bool

func (*NumericType) Tag 

func (t *NumericType) Tag() TypeTag

func (*NumericType) TypeAnnotationState 

func (*NumericType) TypeAnnotationState() TypeAnnotationState

func (*NumericType) Unify 

func (*NumericType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

func (*NumericType) WithByteSize 

func (t *NumericType) WithByteSize(size int) *NumericType

func (*NumericType) WithIntRange 

func (t *NumericType) WithIntRange(min *big.Int, max *big.Int) *NumericType

func (*NumericType) WithSaturatingFunctions 

func (t *NumericType) WithSaturatingFunctions(saturatingArithmetic SaturatingArithmeticSupport) *NumericType

func (*NumericType) WithTag 

func (t *NumericType) WithTag(tag TypeTag) *NumericType

type Occurrence 

type Occurrence struct {
	Origin   *Origin
	StartPos Position
	EndPos   Position
}

type Occurrences 

type Occurrences struct {
	// contains filtered or unexported fields
}

func NewOccurrences 

func NewOccurrences() *Occurrences

func (*Occurrences) All 

func (o *Occurrences) All() []Occurrence

func (*Occurrences) Find 

func (o *Occurrences) Find(pos Position) *Occurrence

func (*Occurrences) FindAll 

func (o *Occurrences) FindAll(pos Position) []Occurrence

func (*Occurrences) Put 

func (o *Occurrences) Put(startPos, endPos ast.Position, origin *Origin)

type OptionalType 

type OptionalType struct {
	Type Type
	// contains filtered or unexported fields
}

OptionalType represents the optional variant of another type

func NewOptionalType 

func NewOptionalType(memoryGauge common.MemoryGauge, typ Type) *OptionalType

func (*OptionalType) CheckInstantiated 

func (t *OptionalType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*OptionalType) ContainFieldsOrElements 

func (t *OptionalType) ContainFieldsOrElements() bool

func (*OptionalType) Equal 

func (t *OptionalType) Equal(other Type) bool

func (*OptionalType) GetMembers 

func (t *OptionalType) GetMembers() map[string]MemberResolver

func (*OptionalType) ID 

func (t *OptionalType) ID() TypeID

func (*OptionalType) IsComparable 

func (*OptionalType) IsComparable() bool

func (*OptionalType) IsEquatable 

func (t *OptionalType) IsEquatable() bool

func (*OptionalType) IsExportable 

func (t *OptionalType) IsExportable(results map[*Member]bool) bool

func (*OptionalType) IsImportable 

func (t *OptionalType) IsImportable(results map[*Member]bool) bool

func (*OptionalType) IsInvalidType 

func (t *OptionalType) IsInvalidType() bool

func (*OptionalType) IsOrContainsReferenceType 

func (t *OptionalType) IsOrContainsReferenceType() bool

func (*OptionalType) IsPrimitiveType 

func (t *OptionalType) IsPrimitiveType() bool

func (*OptionalType) IsResourceType 

func (t *OptionalType) IsResourceType() bool

func (*OptionalType) IsStorable 

func (t *OptionalType) IsStorable(results map[*Member]bool) bool

func (*OptionalType) IsType 

func (*OptionalType) IsType()

func (*OptionalType) Map 

func (t *OptionalType) Map(memoryGauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*OptionalType) QualifiedString 

func (t *OptionalType) QualifiedString() string

func (*OptionalType) Resolve 

func (t *OptionalType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*OptionalType) RewriteWithIntersectionTypes 

func (t *OptionalType) RewriteWithIntersectionTypes() (Type, bool)

func (*OptionalType) String 

func (t *OptionalType) String() string

func (*OptionalType) SupportedEntitlements 

func (t *OptionalType) SupportedEntitlements() *EntitlementSet

func (*OptionalType) Tag 

func (t *OptionalType) Tag() TypeTag

func (*OptionalType) TypeAnnotationState 

func (t *OptionalType) TypeAnnotationState() TypeAnnotationState

func (*OptionalType) Unify 

func (t *OptionalType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type Origin 

type Origin struct {
	Type            Type
	StartPos        *ast.Position
	EndPos          *ast.Position
	DocString       string
	Occurrences     []ast.Range
	DeclarationKind common.DeclarationKind
}

type Parameter 

type Parameter struct {
	TypeAnnotation  TypeAnnotation
	DefaultArgument Type
	Label           string
	Identifier      string
}

func (Parameter) EffectiveArgumentLabel 

func (p Parameter) EffectiveArgumentLabel() string

EffectiveArgumentLabel returns the effective argument label that an argument in a call must use: If no argument label is declared for parameter, the parameter name is used as the argument label

func (Parameter) QualifiedString 

func (p Parameter) QualifiedString() string

func (Parameter) String 

func (p Parameter) String() string

type ParameterizedType 

type ParameterizedType interface {
	Type
	TypeParameters() []*TypeParameter
	Instantiate(
		memoryGauge common.MemoryGauge,
		typeArguments []Type,
		astTypeArguments []*ast.TypeAnnotation,
		report func(err error),
	) Type
	BaseType() Type
	TypeArguments() []Type
}

ParameterizedType is a type which might have type parameters

type Position 

type Position struct {
	// line number, starting at 1
	Line int
	// column number, starting at 0 (byte count)
	Column int
}

func ASTToSemaPosition 

func ASTToSemaPosition(position ast.Position) Position

func (Position) Compare 

func (pos Position) Compare(other intervalst.Position) int

func (Position) String 

func (pos Position) String() string

type PositionInfo 

type PositionInfo struct {
	Occurrences         *Occurrences
	VariableOrigins     map[*Variable]*Origin
	MemberOrigins       map[Type]map[string]*Origin
	MemberAccesses      *MemberAccesses
	Ranges              *Ranges
	FunctionInvocations *FunctionInvocations
}

func NewPositionInfo 

func NewPositionInfo() *PositionInfo

type PostConditionsRewrite 

type PostConditionsRewrite struct {
	BeforeStatements        []ast.Statement
	RewrittenPostConditions []ast.Condition
}

type PreviousResourceInvalidationNote 

type PreviousResourceInvalidationNote struct {
	ResourceInvalidation
	ast.Range
}

func (PreviousResourceInvalidationNote) Message 

func (n PreviousResourceInvalidationNote) Message() string

type PrimitiveAccess 

type PrimitiveAccess ast.PrimitiveAccess

func (PrimitiveAccess) Equal 

func (a PrimitiveAccess) Equal(other Access) bool

func (PrimitiveAccess) ID 

func (PrimitiveAccess) ID() TypeID

func (PrimitiveAccess) IsPrimitiveAccess 

func (PrimitiveAccess) IsPrimitiveAccess() bool

func (PrimitiveAccess) PermitsAccess 

func (a PrimitiveAccess) PermitsAccess(otherAccess Access) bool

func (PrimitiveAccess) QualifiedKeyword 

func (a PrimitiveAccess) QualifiedKeyword() string

func (PrimitiveAccess) QualifiedString 

func (a PrimitiveAccess) QualifiedString() string

func (PrimitiveAccess) String 

func (a PrimitiveAccess) String() string

type PurityCheckScope 

type PurityCheckScope struct {
	// whether encountering an impure operation should cause an error
	EnforcePurity   bool
	ActivationDepth int
}

type PurityError 

type PurityError struct {
	ast.Range
}

func (*PurityError) Error 

func (e *PurityError) Error() string

func (*PurityError) IsUserError 

func (*PurityError) IsUserError()

type Range 

type Range struct {
	Type            Type
	Identifier      string
	DocString       string
	DeclarationKind common.DeclarationKind
}

type Ranges 

type Ranges struct {
	// contains filtered or unexported fields
}

func NewRanges 

func NewRanges() *Ranges

func (*Ranges) All 

func (r *Ranges) All() []Range

func (*Ranges) FindAll 

func (r *Ranges) FindAll(pos Position) []Range

func (*Ranges) Put 

func (r *Ranges) Put(startPos, endPos ast.Position, ra Range)

type ReadOnlyTargetAssignmentError 

type ReadOnlyTargetAssignmentError struct {
	ast.Range
}

func (*ReadOnlyTargetAssignmentError) Error 

func (e *ReadOnlyTargetAssignmentError) Error() string

func (*ReadOnlyTargetAssignmentError) IsUserError 

func (*ReadOnlyTargetAssignmentError) IsUserError()

type RedeclarationError 

type RedeclarationError struct {
	PreviousPos *ast.Position
	Name        string
	Pos         ast.Position
	Kind        common.DeclarationKind
}

func (*RedeclarationError) EndPosition 

func (e *RedeclarationError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*RedeclarationError) Error 

func (e *RedeclarationError) Error() string

func (*RedeclarationError) ErrorNotes 

func (e *RedeclarationError) ErrorNotes() []errors.ErrorNote

func (*RedeclarationError) IsUserError 

func (*RedeclarationError) IsUserError()

func (*RedeclarationError) StartPosition 

func (e *RedeclarationError) StartPosition() ast.Position

type RedeclarationNote 

type RedeclarationNote struct {
	ast.Range
}

func (RedeclarationNote) Message 

func (n RedeclarationNote) Message() string

type ReferenceToAnOptionalError 

type ReferenceToAnOptionalError struct {
	ReferencedOptionalType *OptionalType
	ast.Range
}

func (*ReferenceToAnOptionalError) Error 

func (e *ReferenceToAnOptionalError) Error() string

func (*ReferenceToAnOptionalError) IsUserError 

func (*ReferenceToAnOptionalError) IsUserError()

func (*ReferenceToAnOptionalError) SecondaryError 

func (e *ReferenceToAnOptionalError) SecondaryError() string

type ReferenceType 

type ReferenceType struct {
	Type          Type
	Authorization Access
}

ReferenceType represents the reference to a value

func MaybeReferenceType 

func MaybeReferenceType(typ Type) (*ReferenceType, bool)

func NewReferenceType 

func NewReferenceType(
	memoryGauge common.MemoryGauge,
	authorization Access,
	typ Type,
) *ReferenceType

func (*ReferenceType) AllowsValueIndexingAssignment 

func (t *ReferenceType) AllowsValueIndexingAssignment() bool

func (*ReferenceType) CheckInstantiated 

func (t *ReferenceType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*ReferenceType) ContainFieldsOrElements 

func (*ReferenceType) ContainFieldsOrElements() bool

func (*ReferenceType) ElementType 

func (t *ReferenceType) ElementType(isAssignment bool) Type

func (*ReferenceType) Equal 

func (t *ReferenceType) Equal(other Type) bool

func (*ReferenceType) GetMembers 

func (t *ReferenceType) GetMembers() map[string]MemberResolver

func (*ReferenceType) ID 

func (t *ReferenceType) ID() TypeID

func (*ReferenceType) IndexingType 

func (t *ReferenceType) IndexingType() Type

func (*ReferenceType) IsComparable 

func (*ReferenceType) IsComparable() bool

func (*ReferenceType) IsEquatable 

func (*ReferenceType) IsEquatable() bool

func (*ReferenceType) IsExportable 

func (t *ReferenceType) IsExportable(_ map[*Member]bool) bool

func (*ReferenceType) IsImportable 

func (t *ReferenceType) IsImportable(_ map[*Member]bool) bool

func (*ReferenceType) IsInvalidType 

func (t *ReferenceType) IsInvalidType() bool

func (*ReferenceType) IsOrContainsReferenceType 

func (*ReferenceType) IsOrContainsReferenceType() bool

func (*ReferenceType) IsPrimitiveType 

func (t *ReferenceType) IsPrimitiveType() bool

func (*ReferenceType) IsResourceType 

func (t *ReferenceType) IsResourceType() bool

func (*ReferenceType) IsStorable 

func (t *ReferenceType) IsStorable(_ map[*Member]bool) bool

func (*ReferenceType) IsType 

func (*ReferenceType) IsType()

func (*ReferenceType) IsValidIndexingType 

func (t *ReferenceType) IsValidIndexingType(ty Type) bool

func (*ReferenceType) Map 

func (t *ReferenceType) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*ReferenceType) QualifiedString 

func (t *ReferenceType) QualifiedString() string

func (*ReferenceType) Resolve 

func (t *ReferenceType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*ReferenceType) RewriteWithIntersectionTypes 

func (t *ReferenceType) RewriteWithIntersectionTypes() (Type, bool)

func (*ReferenceType) String 

func (t *ReferenceType) String() string

func (*ReferenceType) Tag 

func (t *ReferenceType) Tag() TypeTag

func (*ReferenceType) TypeAnnotationState 

func (t *ReferenceType) TypeAnnotationState() TypeAnnotationState

func (*ReferenceType) TypeIndexingElementType 

func (t *ReferenceType) TypeIndexingElementType(indexingType Type, _ func() ast.Range) (Type, error)

func (*ReferenceType) Unify 

func (t *ReferenceType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type ResolvedLocation 

type ResolvedLocation struct {
	Location    common.Location
	Identifiers []ast.Identifier
}

type Resource 

type Resource struct {
	Variable *Variable
	Member   *Member
}

A Resource is a variable or a member

type ResourceCapturingError 

type ResourceCapturingError struct {
	Name string
	Pos  ast.Position
}

func (*ResourceCapturingError) EndPosition 

func (e *ResourceCapturingError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*ResourceCapturingError) Error 

func (e *ResourceCapturingError) Error() string

func (*ResourceCapturingError) IsUserError 

func (*ResourceCapturingError) IsUserError()

func (*ResourceCapturingError) StartPosition 

func (e *ResourceCapturingError) StartPosition() ast.Position

type ResourceFieldNotInvalidatedError 

type ResourceFieldNotInvalidatedError struct {
	Type      Type
	FieldName string
	Pos       ast.Position
}

func (*ResourceFieldNotInvalidatedError) EndPosition 

func (e *ResourceFieldNotInvalidatedError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*ResourceFieldNotInvalidatedError) Error 

func (e *ResourceFieldNotInvalidatedError) Error() string

func (*ResourceFieldNotInvalidatedError) IsUserError 

func (*ResourceFieldNotInvalidatedError) IsUserError()

func (*ResourceFieldNotInvalidatedError) SecondaryError 

func (e *ResourceFieldNotInvalidatedError) SecondaryError() string

func (*ResourceFieldNotInvalidatedError) StartPosition 

func (e *ResourceFieldNotInvalidatedError) StartPosition() ast.Position

type ResourceInfo 

type ResourceInfo struct {
	Parent *ResourceInfo
	// contains filtered or unexported fields
}

func (*ResourceInfo) Clone 

func (ris *ResourceInfo) Clone() ResourceInfo

Clone returns a new child resource invalidation set that contains all entries of this parent set. Changes to the returned set will only be applied in the returned set, not the parent.

func (ResourceInfo) DefinitivelyInvalidated 

func (ris ResourceInfo) DefinitivelyInvalidated() bool

func (*ResourceInfo) DeleteLocally 

func (ris *ResourceInfo) DeleteLocally(invalidation ResourceInvalidation)

DeleteLocally removes the given resource invalidation from this current set.

NOTE: the invalidation still might exist in a parent afterwards, i.e. call to Contains might still return true!

func (ResourceInfo) Invalidation 

func (ris ResourceInfo) Invalidation() *ResourceInvalidation

func (*ResourceInfo) MaybeRecordInvalidation 

func (ris *ResourceInfo) MaybeRecordInvalidation(invalidation ResourceInvalidation) ResourceInvalidation

MaybeRecordInvalidation records the given resource invalidation, if no invalidation has yet been recorded for the given resource.

type ResourceInvalidation 

type ResourceInvalidation struct {
	Kind     ResourceInvalidationKind
	StartPos ast.Position
	EndPos   ast.Position
}

type ResourceInvalidationKind 

type ResourceInvalidationKind uint
const (
	ResourceInvalidationKindUnknown ResourceInvalidationKind = iota
	ResourceInvalidationKindMoveDefinite
	ResourceInvalidationKindMovePotential
	ResourceInvalidationKindMoveTemporary
	ResourceInvalidationKindDestroyDefinite
	ResourceInvalidationKindDestroyPotential
)

func (ResourceInvalidationKind) AsPotential 

func (k ResourceInvalidationKind) AsPotential() ResourceInvalidationKind

func (ResourceInvalidationKind) CoarseNoun 

func (i ResourceInvalidationKind) CoarseNoun() string

func (ResourceInvalidationKind) CoarsePassiveVerb 

func (k ResourceInvalidationKind) CoarsePassiveVerb() string

func (ResourceInvalidationKind) DetailedNoun 

func (k ResourceInvalidationKind) DetailedNoun() string

func (ResourceInvalidationKind) IsDefinite 

func (k ResourceInvalidationKind) IsDefinite() bool

func (ResourceInvalidationKind) String 

func (i ResourceInvalidationKind) String() string

type ResourceLossError 

type ResourceLossError struct {
	ast.Range
}

func (*ResourceLossError) Error 

func (e *ResourceLossError) Error() string

func (*ResourceLossError) IsUserError 

func (*ResourceLossError) IsUserError()

type ResourceMethodBindingError 

type ResourceMethodBindingError struct {
	ast.Range
}

func (*ResourceMethodBindingError) Error 

func (e *ResourceMethodBindingError) Error() string

func (*ResourceMethodBindingError) IsUserError 

func (*ResourceMethodBindingError) IsUserError()

type ResourceUseAfterInvalidationError 

type ResourceUseAfterInvalidationError struct {
	Invalidation ResourceInvalidation
	ast.Range
}

func (*ResourceUseAfterInvalidationError) Error 

func (e *ResourceUseAfterInvalidationError) Error() string

func (*ResourceUseAfterInvalidationError) ErrorNotes 

func (e *ResourceUseAfterInvalidationError) ErrorNotes() []errors.ErrorNote

func (*ResourceUseAfterInvalidationError) IsUserError 

func (*ResourceUseAfterInvalidationError) IsUserError()

func (*ResourceUseAfterInvalidationError) SecondaryError 

func (e *ResourceUseAfterInvalidationError) SecondaryError() string

type Resources 

type Resources struct {
	// contains filtered or unexported fields
}

Resources is a map which contains invalidation info for resources.

func NewResources 

func NewResources() *Resources

func (*Resources) Clone 

func (ris *Resources) Clone() *Resources

func (*Resources) ForEach 

func (ris *Resources) ForEach(f func(resource Resource, info ResourceInfo))

func (*Resources) Get 

func (ris *Resources) Get(resource Resource) ResourceInfo

func (*Resources) MaybeRecordInvalidation 

func (ris *Resources) MaybeRecordInvalidation(resource Resource, invalidation ResourceInvalidation)

MaybeRecordInvalidation records the given resource invalidation, if no invalidation has yet been recorded for the given resource.

func (*Resources) MergeBranches 

func (ris *Resources) MergeBranches(
	thenResources *Resources,
	thenReturnInfo *ReturnInfo,
	elseResources *Resources,
	elseReturnInfo *ReturnInfo,
)

MergeBranches merges the given resources from two branches into these resources. Invalidations occurring in both branches are considered definitive, other new invalidations are only considered potential. The else resources are optional.

func (*Resources) Reclaim 

func (ris *Resources) Reclaim()

func (*Resources) RemoveTemporaryMoveInvalidation 

func (ris *Resources) RemoveTemporaryMoveInvalidation(resource Resource, invalidation ResourceInvalidation)

RemoveTemporaryMoveInvalidation removes the given invalidation from the set of invalidations for the given resource.

func (*Resources) Size 

func (ris *Resources) Size() int

func (*Resources) String 

func (ris *Resources) String() string

type ResultVariableConflictError 

type ResultVariableConflictError struct {
	Kind                common.DeclarationKind
	Pos                 ast.Position
	ReturnTypeRange     ast.Range
	PostConditionsRange ast.Range
}

func (*ResultVariableConflictError) EndPosition 

func (e *ResultVariableConflictError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*ResultVariableConflictError) Error 

func (e *ResultVariableConflictError) Error() string

func (*ResultVariableConflictError) ErrorNotes 

func (e *ResultVariableConflictError) ErrorNotes() []errors.ErrorNote

func (*ResultVariableConflictError) IsUserError 

func (*ResultVariableConflictError) IsUserError()

func (*ResultVariableConflictError) SecondaryError 

func (*ResultVariableConflictError) SecondaryError() string

func (*ResultVariableConflictError) StartPosition 

func (e *ResultVariableConflictError) StartPosition() ast.Position

type ResultVariablePostConditionsNote 

type ResultVariablePostConditionsNote struct {
	ast.Range
}

func (ResultVariablePostConditionsNote) Message 

func (ResultVariablePostConditionsNote) Message() string

type ResultVariableReturnTypeNote 

type ResultVariableReturnTypeNote struct {
	ast.Range
}

func (ResultVariableReturnTypeNote) Message 

func (ResultVariableReturnTypeNote) Message() string

type ReturnInfo 

type ReturnInfo struct {
	// JumpOffsets contains the offsets of all jumps
	// (break or continue statements), potential or definite.
	//
	// If non-empty, indicates that (the branch of) the function
	// contains a potential break or continue statement
	JumpOffsets *persistent.OrderedSet[int]
	// MaybeReturned indicates that (the branch of) the function
	// contains a potentially taken return statement
	MaybeReturned bool
	// DefinitelyReturned indicates that (the branch of) the function
	// contains a definite return statement
	DefinitelyReturned bool
	// DefinitelyHalted indicates that (the branch of) the function
	// contains a definite halt (a function call with a Never return type)
	DefinitelyHalted bool
	// DefinitelyExited indicates that (the branch of)
	// the function either contains a definite return statement,
	// contains a definite halt (a function call with a Never return type),
	// or both.
	//
	// NOTE: this is NOT the same DefinitelyReturned || DefinitelyHalted:
	// For example, for the following program:
	//
	//   if ... {
	//       return
	//
	//       // DefinitelyReturned = true
	//	     // DefinitelyHalted = false
	//	     // DefinitelyExited = true
	//   } else {
	//       panic(...)
	//
	//       // DefinitelyReturned = false
	//	     // DefinitelyHalted = true
	//	     // DefinitelyExited = true
	//   }
	//
	//   // DefinitelyReturned = false
	//   // DefinitelyHalted = false
	//   // DefinitelyExited = true
	DefinitelyExited bool
	// DefinitelyJumped indicates that (the branch of) the function
	// contains a definite break or continue statement
	DefinitelyJumped bool
}

ReturnInfo tracks control-flow information

func NewReturnInfo 

func NewReturnInfo() *ReturnInfo

func (*ReturnInfo) AddJumpOffset 

func (ri *ReturnInfo) AddJumpOffset(offset int)

func (*ReturnInfo) Clone 

func (ri *ReturnInfo) Clone() *ReturnInfo

func (*ReturnInfo) IsUnreachable 

func (ri *ReturnInfo) IsUnreachable() bool

func (*ReturnInfo) MaybeJumped 

func (ri *ReturnInfo) MaybeJumped() bool

func (*ReturnInfo) MergeBranches 

func (ri *ReturnInfo) MergeBranches(thenReturnInfo *ReturnInfo, elseReturnInfo *ReturnInfo)

func (*ReturnInfo) MergePotentiallyUnevaluated 

func (ri *ReturnInfo) MergePotentiallyUnevaluated(temporaryReturnInfo *ReturnInfo)

func (*ReturnInfo) WithNewJumpTarget 

func (ri *ReturnInfo) WithNewJumpTarget(f func())

type ReturnStatementTypes 

type ReturnStatementTypes struct {
	ValueType  Type
	ReturnType Type
}

type RuntimeCastTypes 

type RuntimeCastTypes struct {
	Left  Type
	Right Type
}

type RuntimeTypeConstructor 

type RuntimeTypeConstructor struct {
	Name      string
	Value     *FunctionType
	DocString string
}

type SaturatingArithmeticSupport 

type SaturatingArithmeticSupport struct {
	Add      bool
	Subtract bool
	Multiply bool
	Divide   bool
}

type SaturatingArithmeticType 

type SaturatingArithmeticType interface {
	Type
	SupportsSaturatingAdd() bool
	SupportsSaturatingSubtract() bool
	SupportsSaturatingMultiply() bool
	SupportsSaturatingDivide() bool
}

SaturatingArithmeticType is a type that supports saturating arithmetic functions

type SemanticError 

type SemanticError interface {
	errors.UserError
	ast.HasPosition
	// contains filtered or unexported methods
}

type SignatureAlgorithm 

type SignatureAlgorithm uint8
const (
	SignatureAlgorithmUnknown SignatureAlgorithm = iota
	SignatureAlgorithmECDSA_P256
	SignatureAlgorithmECDSA_secp256k1
	SignatureAlgorithmBLS_BLS12_381
)
  • Existing stored values use these raw values and should not change

NOTE: only add new algorithms, do *NOT* change existing items, reuse raw values for other items, swap the order, etc.

Existing stored values use these raw values and should not change

IMPORTANT: update SignatureAlgorithms

func (SignatureAlgorithm) DocString 

func (algo SignatureAlgorithm) DocString() string

func (SignatureAlgorithm) Name 

func (algo SignatureAlgorithm) Name() string

Name returns the string representation of this signing algorithm.

func (SignatureAlgorithm) RawValue 

func (algo SignatureAlgorithm) RawValue() uint8

func (SignatureAlgorithm) String 

func (i SignatureAlgorithm) String() string

type SimpleType 

type SimpleType struct {
	ValueIndexingInfo ValueIndexingInfo
	NestedTypes       *StringTypeOrderedMap

	Members       func(*SimpleType) map[string]MemberResolver
	QualifiedName string
	TypeID        TypeID
	Name          string
	TypeTag       TypeTag

	Importable    bool
	Exportable    bool
	Equatable     bool
	Comparable    bool
	Storable      bool
	Primitive     bool
	IsResource    bool
	ContainFields bool
	// contains filtered or unexported fields
}

SimpleType represents a simple nominal type.

func (*SimpleType) AllowsValueIndexingAssignment 

func (t *SimpleType) AllowsValueIndexingAssignment() bool

func (*SimpleType) CheckInstantiated 

func (t *SimpleType) CheckInstantiated(_ ast.HasPosition, _ common.MemoryGauge, _ func(err error))

func (*SimpleType) CompositeKind 

func (t *SimpleType) CompositeKind() common.CompositeKind

func (*SimpleType) ContainFieldsOrElements 

func (t *SimpleType) ContainFieldsOrElements() bool

func (*SimpleType) EffectiveInterfaceConformanceSet added in v1.3.0 

func (t *SimpleType) EffectiveInterfaceConformanceSet() *InterfaceSet

func (*SimpleType) ElementType 

func (t *SimpleType) ElementType(isAssignment bool) Type

func (*SimpleType) Equal 

func (t *SimpleType) Equal(other Type) bool

func (*SimpleType) GetMembers 

func (t *SimpleType) GetMembers() map[string]MemberResolver

func (*SimpleType) GetNestedTypes 

func (t *SimpleType) GetNestedTypes() *StringTypeOrderedMap

func (*SimpleType) ID 

func (t *SimpleType) ID() TypeID

func (*SimpleType) IndexingType 

func (t *SimpleType) IndexingType() Type

func (*SimpleType) IsComparable 

func (t *SimpleType) IsComparable() bool

func (*SimpleType) IsContainerType 

func (t *SimpleType) IsContainerType() bool

func (*SimpleType) IsEquatable 

func (t *SimpleType) IsEquatable() bool

func (*SimpleType) IsExportable 

func (t *SimpleType) IsExportable(_ map[*Member]bool) bool

func (*SimpleType) IsImportable 

func (t *SimpleType) IsImportable(_ map[*Member]bool) bool

func (*SimpleType) IsInvalidType 

func (t *SimpleType) IsInvalidType() bool

func (*SimpleType) IsOrContainsReferenceType 

func (*SimpleType) IsOrContainsReferenceType() bool

func (*SimpleType) IsPrimitiveType 

func (t *SimpleType) IsPrimitiveType() bool

func (*SimpleType) IsResourceType 

func (t *SimpleType) IsResourceType() bool

func (*SimpleType) IsStorable 

func (t *SimpleType) IsStorable(_ map[*Member]bool) bool

func (*SimpleType) IsType 

func (*SimpleType) IsType()

func (*SimpleType) Map 

func (t *SimpleType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*SimpleType) QualifiedString 

func (t *SimpleType) QualifiedString() string

func (*SimpleType) Resolve 

func (t *SimpleType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*SimpleType) RewriteWithIntersectionTypes 

func (t *SimpleType) RewriteWithIntersectionTypes() (Type, bool)

func (*SimpleType) String 

func (t *SimpleType) String() string

func (*SimpleType) Tag 

func (t *SimpleType) Tag() TypeTag

func (*SimpleType) TypeAnnotationState 

func (*SimpleType) TypeAnnotationState() TypeAnnotationState

func (*SimpleType) Unify 

func (*SimpleType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type SpecialFunctionDefaultImplementationError 

type SpecialFunctionDefaultImplementationError struct {
	Container  ast.Declaration
	Identifier *ast.Identifier
	KindName   string
}

SpecialFunctionDefaultImplementationError

func (*SpecialFunctionDefaultImplementationError) EndPosition 

func (e *SpecialFunctionDefaultImplementationError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*SpecialFunctionDefaultImplementationError) Error 

func (e *SpecialFunctionDefaultImplementationError) Error() string

func (*SpecialFunctionDefaultImplementationError) IsUserError 

func (*SpecialFunctionDefaultImplementationError) IsUserError()

func (*SpecialFunctionDefaultImplementationError) StartPosition 

func (e *SpecialFunctionDefaultImplementationError) StartPosition() ast.Position

type StringImportElementOrderedMap 

type StringImportElementOrderedMap = orderedmap.OrderedMap[string, ImportElement]

type StringMemberOrderedMap 

type StringMemberOrderedMap = orderedmap.OrderedMap[string, *Member]

func MembersAsMap 

func MembersAsMap(members []*Member) *StringMemberOrderedMap

type StringTypeOrderedMap 

type StringTypeOrderedMap = orderedmap.OrderedMap[string, Type]

type StringVariableOrderedMap 

type StringVariableOrderedMap = orderedmap.OrderedMap[string, *Variable]

type SwapStatementTypes 

type SwapStatementTypes struct {
	LeftType  Type
	RightType Type
}

type SwitchDefaultPositionError 

type SwitchDefaultPositionError struct {
	ast.Range
}

func (*SwitchDefaultPositionError) Error 

func (e *SwitchDefaultPositionError) Error() string

func (*SwitchDefaultPositionError) IsUserError 

func (*SwitchDefaultPositionError) IsUserError()

type TransactionMissingPrepareError 

type TransactionMissingPrepareError struct {
	FirstFieldName string
	FirstFieldPos  ast.Position
}

func (*TransactionMissingPrepareError) EndPosition 

func (e *TransactionMissingPrepareError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*TransactionMissingPrepareError) Error 

func (e *TransactionMissingPrepareError) Error() string

func (*TransactionMissingPrepareError) IsUserError 

func (*TransactionMissingPrepareError) IsUserError()

func (*TransactionMissingPrepareError) StartPosition 

func (e *TransactionMissingPrepareError) StartPosition() ast.Position

type TransactionType 

type TransactionType struct {
	Fields            []string
	PrepareParameters []Parameter
	Parameters        []Parameter
	Members           *StringMemberOrderedMap
	// contains filtered or unexported fields
}

func (*TransactionType) CheckInstantiated 

func (t *TransactionType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*TransactionType) ContainFieldsOrElements 

func (*TransactionType) ContainFieldsOrElements() bool

func (*TransactionType) EntryPointFunctionType 

func (t *TransactionType) EntryPointFunctionType() *FunctionType

func (*TransactionType) Equal 

func (*TransactionType) Equal(other Type) bool

func (*TransactionType) ExecuteFunctionType 

func (*TransactionType) ExecuteFunctionType() *FunctionType

func (*TransactionType) GetMembers 

func (t *TransactionType) GetMembers() map[string]MemberResolver

func (*TransactionType) ID 

func (*TransactionType) ID() TypeID

func (*TransactionType) IsComparable 

func (*TransactionType) IsComparable() bool

func (*TransactionType) IsEquatable 

func (*TransactionType) IsEquatable() bool

func (*TransactionType) IsExportable 

func (*TransactionType) IsExportable(_ map[*Member]bool) bool

func (*TransactionType) IsImportable 

func (t *TransactionType) IsImportable(_ map[*Member]bool) bool

func (*TransactionType) IsInvalidType 

func (*TransactionType) IsInvalidType() bool

func (*TransactionType) IsOrContainsReferenceType 

func (*TransactionType) IsOrContainsReferenceType() bool

func (*TransactionType) IsPrimitiveType 

func (*TransactionType) IsPrimitiveType() bool

func (*TransactionType) IsResourceType 

func (*TransactionType) IsResourceType() bool

func (*TransactionType) IsStorable 

func (*TransactionType) IsStorable(_ map[*Member]bool) bool

func (*TransactionType) IsType 

func (*TransactionType) IsType()

func (*TransactionType) Map 

func (t *TransactionType) Map(_ common.MemoryGauge, _ map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*TransactionType) PrepareFunctionType 

func (t *TransactionType) PrepareFunctionType() *FunctionType

func (*TransactionType) QualifiedString 

func (*TransactionType) QualifiedString() string

func (*TransactionType) Resolve 

func (t *TransactionType) Resolve(_ *TypeParameterTypeOrderedMap) Type

func (*TransactionType) RewriteWithIntersectionTypes 

func (t *TransactionType) RewriteWithIntersectionTypes() (Type, bool)

func (*TransactionType) String 

func (*TransactionType) String() string

func (*TransactionType) Tag 

func (t *TransactionType) Tag() TypeTag

func (*TransactionType) TypeAnnotationState 

func (*TransactionType) TypeAnnotationState() TypeAnnotationState

func (*TransactionType) Unify 

func (*TransactionType) Unify(
	_ Type,
	_ *TypeParameterTypeOrderedMap,
	_ func(err error),
	_ common.MemoryGauge,
	_ ast.HasPosition,
) bool

type Type 

type Type interface {
	IsType()
	ID() TypeID
	Tag() TypeTag
	String() string
	QualifiedString() string
	Equal(other Type) bool

	// IsPrimitiveType returns true if the type is itself a primitive,
	// Note that the container of a primitive type (e.g. optionals, arrays, dictionaries, etc.)
	// are not a primitive.
	IsPrimitiveType() bool

	// IsResourceType returns true if the type is itself a resource (a `CompositeType` with resource kind),
	// or it contains a resource type (e.g. for optionals, arrays, dictionaries, etc.)
	IsResourceType() bool

	// IsInvalidType returns true if the type is itself the invalid type (see `InvalidType`),
	// or it contains an invalid type (e.g. for optionals, arrays, dictionaries, etc.)
	IsInvalidType() bool

	// IsOrContainsReferenceType returns true if the type is itself a reference type,
	// or it contains a reference type (e.g. for optionals, arrays, dictionaries, etc.)
	IsOrContainsReferenceType() bool

	// IsStorable returns true if the type is allowed to be a stored,
	// e.g. in a field of a composite type.
	//
	// The check if the type is storable is recursive,
	// the results parameter prevents cycles:
	// it is checked at the start of the recursively called function,
	// and pre-set before a recursive call.
	IsStorable(results map[*Member]bool) bool

	// IsExportable returns true if a value of this type can be exported.
	//
	// The check if the type is exportable is recursive,
	// the results parameter prevents cycles:
	// it is checked at the start of the recursively called function,
	// and pre-set before a recursive call.
	IsExportable(results map[*Member]bool) bool

	// IsImportable returns true if values of the type can be imported to a program as arguments
	IsImportable(results map[*Member]bool) bool

	// IsEquatable returns true if values of the type can be equated
	IsEquatable() bool

	// IsComparable returns true if values of the type can be compared
	IsComparable() bool

	// ContainFieldsOrElements returns true if value of the type can have nested values (fields or elements).
	// This notion is to indicate that a type can be used to access its nested values using
	// either index-expression or member-expression. e.g. `foo.bar` or `foo[bar]`.
	// This is used to determine if a field/element of this type should be returning a reference or not.
	//
	// Only a subset of types has this characteristic. e.g:
	//  - Composites
	//  - Interfaces
	//  - Arrays (Variable/Constant sized)
	//  - Dictionaries
	//  - Restricted types
	//  - Optionals of the above.
	//  - Then there are also built-in simple types, like StorageCapabilityControllerType, BlockType, etc.
	//    where the type is implemented as a simple type, but they also have fields.
	//
	// This is different from the existing  `ValueIndexableType` in the sense that it is also implemented by simple types
	// but not all simple types are indexable.
	// On the other-hand, some indexable types (e.g. String) shouldn't be treated/returned as references.
	//
	ContainFieldsOrElements() bool

	TypeAnnotationState() TypeAnnotationState
	RewriteWithIntersectionTypes() (result Type, rewritten bool)

	// Unify attempts to unify the given type with this type, i.e., resolve type parameters
	// in generic types (see `GenericType`) using the given type parameters.
	//
	// For a generic type, unification assigns a given type with a type parameter.
	//
	// If the type parameter has not been previously unified with a type,
	// through an explicitly provided type argument in an invocation
	// or through a previous unification, the type parameter is assigned the given type.
	//
	// If the type parameter has already been previously unified with a type,
	// the type parameter's unified .
	//
	// The boolean return value indicates if a generic type was encountered during unification.
	// For primitives (e.g. `Int`, `String`, etc.) it would be false, as .
	// For types with nested types (e.g. optionals, arrays, and dictionaries)
	// the result is the successful unification of the inner types.
	//
	// The boolean return value does *not* indicate if unification succeeded or not.
	//
	Unify(
		other Type,
		typeParameters *TypeParameterTypeOrderedMap,
		report func(err error),
		memoryGauge common.MemoryGauge,
		outerRange ast.HasPosition,
	) bool

	// Resolve returns a type that is free of generic types (see `GenericType`),
	// i.e. it resolves the type parameters in generic types given the type parameter
	// unifications of `typeParameters`.
	//
	// If resolution fails, it returns `nil`.
	//
	Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

	GetMembers() map[string]MemberResolver

	// applies `f` to all the types syntactically comprising this type.
	// i.e. `[T]` would map to `f([f(T)])`, but the internals of composite types are not
	// inspected, as they appear simply as nominal types in annotations
	Map(memoryGauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

	CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))
}

func CheckIntersectionType 

func CheckIntersectionType(
	memoryGauge common.MemoryGauge,
	types []*InterfaceType,
	report func(func(*ast.IntersectionType) error),
) Type

func CheckPathLiteral 

func CheckPathLiteral(
	gauge common.MemoryGauge,
	domain string,
	identifier string,
	domainRange ast.HasPosition,
	identifierRange ast.HasPosition,
) (Type, error)

func LeastCommonSuperType 

func LeastCommonSuperType(types ...Type) Type

func MustInstantiate 

func MustInstantiate(t ParameterizedType, typeArguments ...Type) Type

func TypeActivationNestedType 

func TypeActivationNestedType(typeActivation *VariableActivation, qualifiedIdentifier string) Type

func UnwrapOptionalType 

func UnwrapOptionalType(ty Type) Type

UnwrapOptionalType returns the type if it is not an optional type, or the inner-most type if it is (optional types are repeatedly unwrapped)

type TypeAnnotation 

type TypeAnnotation struct {
	Type       Type
	IsResource bool
}

func NewTypeAnnotation 

func NewTypeAnnotation(ty Type) TypeAnnotation

func (TypeAnnotation) Equal 

func (a TypeAnnotation) Equal(other TypeAnnotation) bool

func (TypeAnnotation) Map 

func (a TypeAnnotation) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) TypeAnnotation

func (TypeAnnotation) QualifiedString 

func (a TypeAnnotation) QualifiedString() string

func (TypeAnnotation) String 

func (a TypeAnnotation) String() string

func (TypeAnnotation) TypeAnnotationState 

func (a TypeAnnotation) TypeAnnotationState() TypeAnnotationState

type TypeAnnotationRequiredError 

type TypeAnnotationRequiredError struct {
	Cause string
	Pos   ast.Position
}

func (*TypeAnnotationRequiredError) EndPosition 

func (e *TypeAnnotationRequiredError) EndPosition(common.MemoryGauge) ast.Position

func (*TypeAnnotationRequiredError) Error 

func (e *TypeAnnotationRequiredError) Error() string

func (*TypeAnnotationRequiredError) IsUserError 

func (*TypeAnnotationRequiredError) IsUserError()

func (*TypeAnnotationRequiredError) StartPosition 

func (e *TypeAnnotationRequiredError) StartPosition() ast.Position

type TypeAnnotationState 

type TypeAnnotationState uint
const (
	TypeAnnotationStateUnknown TypeAnnotationState = iota
	TypeAnnotationStateValid
	// Resource annotations (@) are invalid on non-resource types (e.g. @Int)
	TypeAnnotationStateInvalidResourceAnnotation
	// Resource types must have a resource annotation (@)
	TypeAnnotationStateMissingResourceAnnotation
	// Entitlement types must only appear in `access` or `auth` modifier positions
	TypeAnnotationStateDirectEntitlementTypeAnnotation
	// attachments types must never appear directly as annotations, and instead
	// should appear only in reference types: e.g. `&A` or `[&A]`
	TypeAnnotationStateDirectAttachmentTypeAnnotation
)

func (TypeAnnotationState) String 

func (i TypeAnnotationState) String() string

type TypeArgumentsCheck 

type TypeArgumentsCheck func(
	memoryGauge common.MemoryGauge,
	typeArguments *TypeParameterTypeOrderedMap,
	astTypeArguments []*ast.TypeAnnotation,
	invocationRange ast.HasPosition,
	report func(err error),
)

type TypeCheckFunc 

type TypeCheckFunc = func() Type

type TypeDeclaration 

type TypeDeclaration interface {
	TypeDeclarationName() string
	TypeDeclarationType() Type
	TypeDeclarationKind() common.DeclarationKind
	TypeDeclarationPosition() *ast.Position
}

type TypeID 

type TypeID = common.TypeID

func InclusiveRangeTypeID 

func InclusiveRangeTypeID(memberTypeID string) TypeID

type TypeIDOrderedSet 

type TypeIDOrderedSet = orderedmap.OrderedMap[common.TypeID, struct{}]

type TypeIndexableType 

type TypeIndexableType interface {
	Type

	IsValidIndexingType(indexingType Type) bool
	TypeIndexingElementType(indexingType Type, astRange func() ast.Range) (Type, error)
	// contains filtered or unexported methods
}

TypeIndexableType is a type which can be indexed into using a type

type TypeMismatchError 

type TypeMismatchError struct {
	ExpectedType Type
	ActualType   Type
	Expression   ast.Expression
	ast.Range
}

func (*TypeMismatchError) Error 

func (e *TypeMismatchError) Error() string

func (*TypeMismatchError) IsUserError 

func (*TypeMismatchError) IsUserError()

func (*TypeMismatchError) SecondaryError 

func (e *TypeMismatchError) SecondaryError() string

type TypeMismatchWithDescriptionError 

type TypeMismatchWithDescriptionError struct {
	ActualType              Type
	ExpectedTypeDescription string
	ast.Range
}

func (*TypeMismatchWithDescriptionError) Error 

func (e *TypeMismatchWithDescriptionError) Error() string

func (*TypeMismatchWithDescriptionError) IsUserError 

func (*TypeMismatchWithDescriptionError) IsUserError()

func (*TypeMismatchWithDescriptionError) SecondaryError 

func (e *TypeMismatchWithDescriptionError) SecondaryError() string

type TypeParameter 

type TypeParameter struct {
	TypeBound Type
	Name      string
	Optional  bool
}

func (TypeParameter) Equal 

func (p TypeParameter) Equal(other *TypeParameter) bool

func (TypeParameter) QualifiedString 

func (p TypeParameter) QualifiedString() string

func (TypeParameter) String 

func (p TypeParameter) String() string

type TypeParameterTypeInferenceError 

type TypeParameterTypeInferenceError struct {
	Name string
	ast.Range
}

func (*TypeParameterTypeInferenceError) Error 

func (e *TypeParameterTypeInferenceError) Error() string

func (*TypeParameterTypeInferenceError) IsUserError 

func (*TypeParameterTypeInferenceError) IsUserError()

type TypeParameterTypeMismatchError 

type TypeParameterTypeMismatchError struct {
	TypeParameter *TypeParameter
	ExpectedType  Type
	ActualType    Type
	ast.Range
}

func (*TypeParameterTypeMismatchError) Error 

func (e *TypeParameterTypeMismatchError) Error() string

func (*TypeParameterTypeMismatchError) IsUserError 

func (*TypeParameterTypeMismatchError) IsUserError()

func (*TypeParameterTypeMismatchError) SecondaryError 

func (e *TypeParameterTypeMismatchError) SecondaryError() string

type TypeParameterTypeOrderedMap 

type TypeParameterTypeOrderedMap = orderedmap.OrderedMap[*TypeParameter, Type]

type TypeTag 

type TypeTag struct {
	// contains filtered or unexported fields
}

TypeTag is a bitmask representation for types. Each type has a unique dedicated bit/bit-pattern in the bitmask. The mask consist of two sections: `lowerMask` and the `upperMask`. Each section can represent 64-types.

func (TypeTag) And 

func (t TypeTag) And(tag TypeTag) TypeTag

func (TypeTag) BelongsTo 

func (t TypeTag) BelongsTo(typeTag TypeTag) bool

func (TypeTag) ContainsAny 

func (t TypeTag) ContainsAny(typeTags ...TypeTag) bool

func (TypeTag) Equals 

func (t TypeTag) Equals(tag TypeTag) bool

func (TypeTag) Not 

func (t TypeTag) Not() TypeTag

func (TypeTag) Or 

func (t TypeTag) Or(tag TypeTag) TypeTag

type UnauthorizedReferenceAssignmentError 

type UnauthorizedReferenceAssignmentError struct {
	RequiredAccess [2]Access
	FoundAccess    Access
	ast.Range
}

func (*UnauthorizedReferenceAssignmentError) Error 

func (e *UnauthorizedReferenceAssignmentError) Error() string

func (*UnauthorizedReferenceAssignmentError) IsUserError 

func (*UnauthorizedReferenceAssignmentError) IsUserError()

func (*UnauthorizedReferenceAssignmentError) SecondaryError 

func (e *UnauthorizedReferenceAssignmentError) SecondaryError() string

type UnconvertableTypeError added in v1.3.0 

type UnconvertableTypeError struct {
	Type ast.Type
	ast.Range
}

func (*UnconvertableTypeError) Error added in v1.3.0 

func (e *UnconvertableTypeError) Error() string

func (*UnconvertableTypeError) IsUserError added in v1.3.0 

func (*UnconvertableTypeError) IsUserError()

type UninitializedFieldAccessError 

type UninitializedFieldAccessError struct {
	Name string
	Pos  ast.Position
}

func (*UninitializedFieldAccessError) EndPosition 

func (e *UninitializedFieldAccessError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*UninitializedFieldAccessError) Error 

func (e *UninitializedFieldAccessError) Error() string

func (*UninitializedFieldAccessError) IsUserError 

func (*UninitializedFieldAccessError) IsUserError()

func (*UninitializedFieldAccessError) StartPosition 

func (e *UninitializedFieldAccessError) StartPosition() ast.Position

type UninitializedUseError 

type UninitializedUseError struct {
	Name string
	Pos  ast.Position
}

func (*UninitializedUseError) EndPosition 

func (e *UninitializedUseError) EndPosition(memoryGauge common.MemoryGauge) ast.Position

func (*UninitializedUseError) Error 

func (e *UninitializedUseError) Error() string

func (*UninitializedUseError) IsUserError 

func (*UninitializedUseError) IsUserError()

func (*UninitializedUseError) StartPosition 

func (e *UninitializedUseError) StartPosition() ast.Position

type UnknownSpecialFunctionError 

type UnknownSpecialFunctionError struct {
	Pos ast.Position
}

func (*UnknownSpecialFunctionError) EndPosition 

func (e *UnknownSpecialFunctionError) EndPosition(common.MemoryGauge) ast.Position

func (*UnknownSpecialFunctionError) Error 

func (e *UnknownSpecialFunctionError) Error() string

func (*UnknownSpecialFunctionError) IsUserError 

func (*UnknownSpecialFunctionError) IsUserError()

func (*UnknownSpecialFunctionError) StartPosition 

func (e *UnknownSpecialFunctionError) StartPosition() ast.Position

type UnparameterizedTypeInstantiationError 

type UnparameterizedTypeInstantiationError struct {
	ActualTypeArgumentCount int
	ast.Range
}

func (*UnparameterizedTypeInstantiationError) Error 

func (e *UnparameterizedTypeInstantiationError) Error() string

func (*UnparameterizedTypeInstantiationError) IsUserError 

func (*UnparameterizedTypeInstantiationError) IsUserError()

func (*UnparameterizedTypeInstantiationError) SecondaryError 

func (e *UnparameterizedTypeInstantiationError) SecondaryError() string

type UnreachableStatementError 

type UnreachableStatementError struct {
	ast.Range
}

func (*UnreachableStatementError) Error 

func (e *UnreachableStatementError) Error() string

func (*UnreachableStatementError) IsUserError 

func (*UnreachableStatementError) IsUserError()

func (*UnreachableStatementError) SecondaryError 

func (e *UnreachableStatementError) SecondaryError() string

type UnrepresentableEntitlementMapOutputError 

type UnrepresentableEntitlementMapOutputError struct {
	Input EntitlementSetAccess
	Map   *EntitlementMapType
	ast.Range
}

UnrepresentableEntitlementMapOutputError

func (*UnrepresentableEntitlementMapOutputError) EndPosition 

func (e *UnrepresentableEntitlementMapOutputError) EndPosition(common.MemoryGauge) ast.Position

func (*UnrepresentableEntitlementMapOutputError) Error 

func (e *UnrepresentableEntitlementMapOutputError) Error() string

func (*UnrepresentableEntitlementMapOutputError) IsUserError 

func (*UnrepresentableEntitlementMapOutputError) IsUserError()

func (*UnrepresentableEntitlementMapOutputError) SecondaryError 

func (e *UnrepresentableEntitlementMapOutputError) SecondaryError() string

func (*UnrepresentableEntitlementMapOutputError) StartPosition 

func (e *UnrepresentableEntitlementMapOutputError) StartPosition() ast.Position

type UnresolvedImportError 

type UnresolvedImportError struct {
	ImportLocation common.Location
	ast.Range
}

func (*UnresolvedImportError) Error 

func (e *UnresolvedImportError) Error() string

func (*UnresolvedImportError) IsUserError 

func (*UnresolvedImportError) IsUserError()

type UnsupportedOptionalChainingAssignmentError 

type UnsupportedOptionalChainingAssignmentError struct {
	ast.Range
}

func (*UnsupportedOptionalChainingAssignmentError) Error 

func (e *UnsupportedOptionalChainingAssignmentError) Error() string

func (*UnsupportedOptionalChainingAssignmentError) IsUserError 

func (*UnsupportedOptionalChainingAssignmentError) IsUserError()

type UnsupportedOverloadingError 

type UnsupportedOverloadingError struct {
	DeclarationKind common.DeclarationKind
	ast.Range
}

func (*UnsupportedOverloadingError) Error 

func (e *UnsupportedOverloadingError) Error() string

func (*UnsupportedOverloadingError) IsUserError 

func (*UnsupportedOverloadingError) IsUserError()

type UnsupportedResourceForLoopError 

type UnsupportedResourceForLoopError struct {
	ast.Range
}

func (*UnsupportedResourceForLoopError) Error 

func (e *UnsupportedResourceForLoopError) Error() string

func (*UnsupportedResourceForLoopError) IsUserError 

func (*UnsupportedResourceForLoopError) IsUserError()

type ValidTopLevelDeclarationsHandlerFunc 

type ValidTopLevelDeclarationsHandlerFunc func(common.Location) common.DeclarationKindSet

type ValueDeclaration 

type ValueDeclaration interface {
	ValueDeclarationName() string
	ValueDeclarationType() Type
	ValueDeclarationDocString() string
	ValueDeclarationKind() common.DeclarationKind
	ValueDeclarationPosition() *ast.Position
	ValueDeclarationIsConstant() bool
	ValueDeclarationArgumentLabels() []string
}

type ValueIndexableType 

type ValueIndexableType interface {
	Type

	AllowsValueIndexingAssignment() bool
	ElementType(isAssignment bool) Type
	IndexingType() Type
	// contains filtered or unexported methods
}

ValueIndexableType is a type which can be indexed into using a value

type ValueIndexingInfo 

type ValueIndexingInfo struct {
	ElementType                   func(_ bool) Type
	IndexingType                  *NumericType
	IsValueIndexableType          bool
	AllowsValueIndexingAssignment bool
}

type Variable 

type Variable struct {
	// Type is the type of the variable
	Type Type
	// Pos is the position where the variable was declared
	Pos        *ast.Position
	Identifier string
	// DocString is the optional docstring
	DocString string

	// ArgumentLabels are the argument labels that must be used in an invocation of the variable
	ArgumentLabels  []string
	DeclarationKind common.DeclarationKind
	// Access is the access modifier
	Access Access
	// ActivationDepth is the depth of scopes in which the variable was declared
	ActivationDepth int
	// IsConstant indicates if the variable is read-only
	IsConstant bool
	// contains filtered or unexported fields
}

type VariableActivation 

type VariableActivation struct {
	Parent         *VariableActivation
	LeaveCallbacks []func(EndPositionGetter)
	Depth          int
	// contains filtered or unexported fields
}

An VariableActivation is a map of strings to variables. It is used to represent an active scope in a program, i.e. it is used as a symbol table during semantic analysis.

func NewVariableActivation 

func NewVariableActivation(parent *VariableActivation) *VariableActivation

NewVariableActivation returns as new activation with the given parent. The parent may be nil.

func (*VariableActivation) Clear 

func (a *VariableActivation) Clear()

Clear removes all variables from this activation.

func (*VariableActivation) DeclareType 

func (a *VariableActivation) DeclareType(declaration TypeDeclaration)

func (*VariableActivation) DeclareValue 

func (a *VariableActivation) DeclareValue(declaration ValueDeclaration)

func (*VariableActivation) Find 

func (a *VariableActivation) Find(name string) *Variable

Find returns the variable for a given name in the activation. It returns nil if no variable is found.

func (*VariableActivation) ForEach 

func (a *VariableActivation) ForEach(cb func(string, *Variable) error) error

ForEach calls the given function for each name-variable pair in the activation. It can be used to iterate over all entries of the activation.

func (*VariableActivation) Set 

func (a *VariableActivation) Set(name string, variable *Variable)

Set sets the given variable.

func (*VariableActivation) SetParent 

func (a *VariableActivation) SetParent(parent *VariableActivation)

SetParent sets the parent of this activation to the given parent and updates the depth.

type VariableActivations 

type VariableActivations struct {
	// contains filtered or unexported fields
}

VariableActivations is a stack of activation records. Each entry represents a new activation record.

The current / most nested activation record can be found at the top of the stack (see function `Current`).

func NewVariableActivations 

func NewVariableActivations(parent *VariableActivation) *VariableActivations

func NewVariableActivationsFromHandler 

func NewVariableActivationsFromHandler(
	handler ActivationHandlerFunc,
	location common.Location,
	defaultActivation *VariableActivation,
) *VariableActivations

func (*VariableActivations) Current 

func (a *VariableActivations) Current() *VariableActivation

Current returns the current / most nested activation, which can be found at the top of the stack. It returns nil if there is no active activation.

func (*VariableActivations) DeclareValue 

func (a *VariableActivations) DeclareValue(declaration ValueDeclaration) (*Variable, error)

func (*VariableActivations) Depth 

func (a *VariableActivations) Depth() int

Depth returns the depth (size) of the activation stack.

func (*VariableActivations) Enter 

func (a *VariableActivations) Enter()

Enter pushes a new empty activation to the top of the activation stack. The new activation has the current activation as its parent.

func (*VariableActivations) Find 

func (a *VariableActivations) Find(name string) *Variable

Find returns the variable for a given name in the current activation. It returns nil if no variable is found or if there is no current activation.

func (*VariableActivations) ForEachVariableDeclaredInAndBelow 

func (a *VariableActivations) ForEachVariableDeclaredInAndBelow(depth int, f func(name string, value *Variable))

func (*VariableActivations) Leave 

func (a *VariableActivations) Leave(getEndPosition func(common.MemoryGauge) ast.Position)

Leave pops the top-most (current) activation from the top of the activation stack.

func (*VariableActivations) Set 

func (a *VariableActivations) Set(name string, variable *Variable)

Set sets the variable in the current activation.

type VariableDeclarationTypes 

type VariableDeclarationTypes struct {
	ValueType       Type
	SecondValueType Type
	TargetType      Type
}

type VariableSizedType 

type VariableSizedType struct {
	Type Type
	// contains filtered or unexported fields
}

VariableSizedType is a variable sized array type

func NewVariableSizedType 

func NewVariableSizedType(memoryGauge common.MemoryGauge, typ Type) *VariableSizedType

func (*VariableSizedType) AllowsValueIndexingAssignment 

func (*VariableSizedType) AllowsValueIndexingAssignment() bool

func (*VariableSizedType) CheckInstantiated 

func (t *VariableSizedType) CheckInstantiated(pos ast.HasPosition, memoryGauge common.MemoryGauge, report func(err error))

func (*VariableSizedType) ContainFieldsOrElements 

func (t *VariableSizedType) ContainFieldsOrElements() bool

func (*VariableSizedType) ElementType 

func (t *VariableSizedType) ElementType(_ bool) Type

func (*VariableSizedType) Equal 

func (t *VariableSizedType) Equal(other Type) bool

func (*VariableSizedType) GetMembers 

func (t *VariableSizedType) GetMembers() map[string]MemberResolver

func (*VariableSizedType) ID 

func (t *VariableSizedType) ID() TypeID

func (*VariableSizedType) IndexingType 

func (t *VariableSizedType) IndexingType() Type

func (*VariableSizedType) IsComparable 

func (t *VariableSizedType) IsComparable() bool

func (*VariableSizedType) IsEquatable 

func (t *VariableSizedType) IsEquatable() bool

func (*VariableSizedType) IsExportable 

func (t *VariableSizedType) IsExportable(results map[*Member]bool) bool

func (*VariableSizedType) IsImportable 

func (t *VariableSizedType) IsImportable(results map[*Member]bool) bool

func (*VariableSizedType) IsInvalidType 

func (t *VariableSizedType) IsInvalidType() bool

func (*VariableSizedType) IsOrContainsReferenceType 

func (t *VariableSizedType) IsOrContainsReferenceType() bool

func (*VariableSizedType) IsPrimitiveType 

func (t *VariableSizedType) IsPrimitiveType() bool

func (*VariableSizedType) IsResourceType 

func (t *VariableSizedType) IsResourceType() bool

func (*VariableSizedType) IsStorable 

func (t *VariableSizedType) IsStorable(results map[*Member]bool) bool

func (*VariableSizedType) IsType 

func (*VariableSizedType) IsType()

func (*VariableSizedType) Map 

func (t *VariableSizedType) Map(gauge common.MemoryGauge, typeParamMap map[*TypeParameter]*TypeParameter, f func(Type) Type) Type

func (*VariableSizedType) QualifiedString 

func (t *VariableSizedType) QualifiedString() string

func (*VariableSizedType) Resolve 

func (t *VariableSizedType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type

func (*VariableSizedType) RewriteWithIntersectionTypes 

func (t *VariableSizedType) RewriteWithIntersectionTypes() (Type, bool)

func (*VariableSizedType) String 

func (t *VariableSizedType) String() string

func (*VariableSizedType) SupportedEntitlements 

func (t *VariableSizedType) SupportedEntitlements() *EntitlementSet

func (*VariableSizedType) Tag 

func (t *VariableSizedType) Tag() TypeTag

func (*VariableSizedType) TypeAnnotationState 

func (t *VariableSizedType) TypeAnnotationState() TypeAnnotationState

func (*VariableSizedType) Unify 

func (t *VariableSizedType) Unify(
	other Type,
	typeParameters *TypeParameterTypeOrderedMap,
	report func(err error),
	memoryGauge common.MemoryGauge,
	outerRange ast.HasPosition,
) bool

type VirtualImport 

type VirtualImport struct {
	ValueElements *StringImportElementOrderedMap
	TypeElements  *StringImportElementOrderedMap
}

func (VirtualImport) AllTypeElements 

func (i VirtualImport) AllTypeElements() *StringImportElementOrderedMap

func (VirtualImport) AllValueElements 

func (i VirtualImport) AllValueElements() *StringImportElementOrderedMap

func (VirtualImport) IsChecking 

func (VirtualImport) IsChecking() bool

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.