Fix type inference, inheritance etc.

encoding/ccf/decode_type.go

@@ -260,6 +260,9 @@ func (d *Decoder) decodeSimpleTypeID() (cadence.Type, error) {
 	case TypeSignedInteger:
 		return cadence.TheSignedIntegerType, nil
 
+	case TypeFixedSizeUnsignedInteger:
+		return cadence.TheFixedSizeUnsignedIntegerType, nil
+
 	case TypeFixedPoint:
 		return cadence.TheFixedPointType, nil
 

runtime/interpreter/interpreter_expression.go

@@ -649,7 +649,7 @@ func (interpreter *Interpreter) NewIntegerValueFromBigInt(value *big.Int, intege
 	// NOTE: cases meter manually and call the unmetered constructors to avoid allocating closures
 
 	switch integerSubType {
-	case sema.IntType, sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
+	case sema.IntType, sema.IntegerType, sema.SignedIntegerType:
 		// BigInt value is already metered at parser.
 		return NewUnmeteredIntValueFromBigInt(value)
 	case sema.UIntType:
@@ -692,7 +692,7 @@ func (interpreter *Interpreter) NewIntegerValueFromBigInt(value *big.Int, intege
 	case sema.UInt128Type:
 		// BigInt value is already metered at parser.
 		return NewUnmeteredUInt128ValueFromBigInt(value)
-	case sema.UInt256Type:
+	case sema.UInt256Type, sema.FixedSizeUnsignedIntegerType:
 		// BigInt value is already metered at parser.
 		return NewUnmeteredUInt256ValueFromBigInt(value)
 

runtime/literal.go

@@ -247,7 +247,7 @@ func convertIntValue(
 		return interpreter.ConvertUInt64(memoryGauge, intValue, interpreter.EmptyLocationRange), nil
 	case sema.UInt128Type:
 		return interpreter.ConvertUInt128(memoryGauge, intValue, interpreter.EmptyLocationRange), nil
-	case sema.UInt256Type:
+	case sema.UInt256Type, sema.FixedSizeUnsignedIntegerType:
 		return interpreter.ConvertUInt256(memoryGauge, intValue, interpreter.EmptyLocationRange), nil
 
 	case sema.Word8Type:

runtime/sema/type.go

@@ -5768,15 +5768,13 @@ func checkSubTypeWithoutEquality(subType Type, superType Type) bool {
 
 	case IntegerType:
 		switch subType {
-		case IntegerType, SignedIntegerType,
-			UIntType,
-			UInt8Type, UInt16Type, UInt32Type, UInt64Type, UInt128Type, UInt256Type,
-			Word8Type, Word16Type, Word32Type, Word64Type, Word128Type, Word256Type:
+		case IntegerType, SignedIntegerType, FixedSizeUnsignedIntegerType,
+			UIntType:
 
 			return true
 
 		default:
-			return IsSubType(subType, SignedIntegerType)
+			return IsSubType(subType, SignedIntegerType) || IsSubType(subType, FixedSizeUnsignedIntegerType)
 		}
 
 	case SignedIntegerType:
@@ -5791,6 +5789,17 @@ func checkSubTypeWithoutEquality(subType Type, superType Type) bool {
 			return false
 		}
 
+	case FixedSizeUnsignedIntegerType:
+		switch subType {
+		case UInt8Type, UInt16Type, UInt32Type, UInt64Type, UInt128Type, UInt256Type,
+			Word8Type, Word16Type, Word32Type, Word64Type, Word128Type, Word256Type:
+
+			return true
+
+		default:
+			return false
+		}
+
 	case FixedPointType:
 		switch subType {
 		case FixedPointType, SignedFixedPointType,

runtime/sema/type_tags.go

@@ -244,21 +244,6 @@ var (
 				Or(Int128TypeTag).
 				Or(Int256TypeTag)
 
-	UnsignedIntegerTypeTag = newTypeTagFromLowerMask(unsignedIntegerTypeMask).
-				Or(UIntTypeTag).
-				Or(UInt8TypeTag).
-				Or(UInt16TypeTag).
-				Or(UInt32TypeTag).
-				Or(UInt64TypeTag).
-				Or(UInt128TypeTag).
-				Or(UInt256TypeTag).
-				Or(Word8TypeTag).
-				Or(Word16TypeTag).
-				Or(Word32TypeTag).
-				Or(Word64TypeTag).
-				Or(Word128TypeTag).
-				Or(Word256TypeTag)
-
 	FixedSizeUnsignedIntegerTypeTag = newTypeTagFromUpperMask(fixedSizeUnsignedIntegerTypeMask).
 					Or(UInt8TypeTag).
 					Or(UInt16TypeTag).
@@ -273,6 +258,10 @@ var (
 					Or(Word128TypeTag).
 					Or(Word256TypeTag)
 
+	UnsignedIntegerTypeTag = newTypeTagFromLowerMask(unsignedIntegerTypeMask).
+				Or(UIntTypeTag).
+				Or(FixedSizeUnsignedIntegerTypeTag)
+
 	IntegerTypeTag = newTypeTagFromLowerMask(integerTypeMask).
 			Or(SignedIntegerTypeTag).
 			Or(UnsignedIntegerTypeTag)
@@ -518,6 +507,8 @@ func findCommonSuperType(joinedTypeTag TypeTag, types ...Type) Type {
 		return InvalidType
 	case joinedTypeTag.BelongsTo(SignedIntegerTypeTag):
 		return SignedIntegerType
+	case joinedTypeTag.BelongsTo(FixedSizeUnsignedIntegerTypeTag):
+		return FixedSizeUnsignedIntegerType
 	case joinedTypeTag.BelongsTo(IntegerTypeTag):
 		return IntegerType
 	case joinedTypeTag.BelongsTo(SignedFixedPointTypeTag):
@@ -717,6 +708,9 @@ func findSuperTypeFromUpperMask(joinedTypeTag TypeTag, types []Type) Type {
 	case accountCapabilityControllerTypeMask:
 		return AccountCapabilityControllerType
 
+	case fixedSizeUnsignedIntegerTypeMask:
+		return FixedSizeUnsignedIntegerType
+
 	default:
 		return nil
 	}

runtime/sema/type_test.go

@@ -892,9 +892,18 @@ func TestCommonSuperType(t *testing.T) {
 				types: []Type{
 					UInt8Type,
 					UInt128Type,
+					UIntType,
 				},
 				expectedSuperType: IntegerType,
 			},
+			{
+				name: "fixed size unsigned integers",
+				types: []Type{
+					UInt8Type,
+					UInt128Type,
+				},
+				expectedSuperType: FixedSizeUnsignedIntegerType,
+			},
 			{
 				name: "heterogeneous simple types",
 				types: []Type{

runtime/stdlib/random.go

@@ -93,10 +93,7 @@ func NewRevertibleRandomFunction(generator RandomGenerator) StandardLibraryValue
 		func(invocation interpreter.Invocation) interpreter.Value {
 			inter := invocation.Interpreter
 
-			// modulo is optional.
-			if len(invocation.Arguments) > 0 {
-				// TODO: Get modulo from the arguments.
-			}
+			// TODO: Check if invocation has an argument and implement modulo operation.
 
 			returnIntegerType := invocation.TypeParameterTypes.Oldest().Value
 			returnIntegerStaticType := interpreter.ConvertSemaToStaticType(inter, returnIntegerType)
@@ -107,7 +104,7 @@ func NewRevertibleRandomFunction(generator RandomGenerator) StandardLibraryValue
 				return interpreter.NewUInt8Value(
 					inter,
 					func() uint8 {
-						return uint8(getRandomBytes(generator, 1)[0])
+						return getRandomBytes(generator, 1)[0]
 					},
 				)
 			case interpreter.PrimitiveStaticTypeUInt16:
@@ -153,7 +150,7 @@ func NewRevertibleRandomFunction(generator RandomGenerator) StandardLibraryValue
 				return interpreter.NewWord8Value(
 					inter,
 					func() uint8 {
-						return uint8(getRandomBytes(generator, 1)[0])
+						return getRandomBytes(generator, 1)[0]
 					},
 				)
 			case interpreter.PrimitiveStaticTypeWord16:

runtime/tests/checker/builtinfunctions_test.go

@@ -252,7 +252,7 @@ func TestCheckFromBigEndianBytes(t *testing.T) {
 	for _, ty := range sema.AllNumberTypes {
 		switch ty {
 		case sema.NumberType, sema.SignedNumberType,
-			sema.IntegerType, sema.SignedIntegerType,
+			sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType,
 			sema.FixedPointType, sema.SignedFixedPointType:
 			continue
 

runtime/tests/checker/integer_test.go

@@ -458,7 +458,7 @@ func TestCheckInvalidIntegerConversionFunctionWithoutArgs(t *testing.T) {
 	for _, ty := range allIntegerTypesAndAddressType {
 		// Only test leaf types
 		switch ty {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 
@@ -488,7 +488,7 @@ func TestCheckFixedPointToIntegerConversion(t *testing.T) {
 	for _, ty := range sema.AllIntegerTypes {
 		// Only test leaf types
 		switch ty {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 
@@ -531,7 +531,8 @@ func TestCheckIntegerLiteralArguments(t *testing.T) {
 
 			switch ty {
 			case sema.IntegerType,
-				sema.SignedIntegerType:
+				sema.SignedIntegerType,
+				sema.FixedSizeUnsignedIntegerType:
 				errs := RequireCheckerErrors(t, err, 1)
 				assert.IsType(t, &sema.InvalidBinaryOperandsError{}, errs[0])
 			default:
@@ -567,7 +568,7 @@ func TestCheckIntegerMinMax(t *testing.T) {
 	for _, ty := range sema.AllIntegerTypes {
 		// Only test leaf types
 		switch ty {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 

runtime/tests/checker/operations_test.go

@@ -600,6 +600,7 @@ func TestCheckNumericSuperTypeBinaryOperations(t *testing.T) {
 		sema.SignedNumberType,
 		sema.IntegerType,
 		sema.SignedIntegerType,
+		sema.FixedSizeUnsignedIntegerType,
 		sema.FixedPointType,
 		sema.SignedFixedPointType,
 	}

runtime/tests/interpreter/arithmetic_test.go

@@ -62,7 +62,7 @@ func init() {
 
 	for _, integerType := range sema.AllIntegerTypes {
 		switch integerType {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 

runtime/tests/interpreter/bitwise_test.go

@@ -97,7 +97,7 @@ func init() {
 
 	for _, integerType := range sema.AllIntegerTypes {
 		switch integerType {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 

runtime/tests/interpreter/builtinfunctions_test.go

@@ -515,7 +515,7 @@ func TestInterpretToBigEndianBytes(t *testing.T) {
 	for _, integerType := range sema.AllNumberTypes {
 		switch integerType {
 		case sema.NumberType, sema.SignedNumberType,
-			sema.IntegerType, sema.SignedIntegerType,
+			sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType,
 			sema.FixedPointType, sema.SignedFixedPointType:
 			continue
 		}
@@ -839,7 +839,7 @@ func TestInterpretFromBigEndianBytes(t *testing.T) {
 	for _, integerType := range sema.AllNumberTypes {
 		switch integerType {
 		case sema.NumberType, sema.SignedNumberType,
-			sema.IntegerType, sema.SignedIntegerType,
+			sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType,
 			sema.FixedPointType, sema.SignedFixedPointType:
 			continue
 		}

runtime/tests/interpreter/integers_test.go

@@ -64,7 +64,7 @@ func init() {
 	for _, integerType := range sema.AllIntegerTypes {
 		// Only test leaf types
 		switch integerType {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 
@@ -705,7 +705,7 @@ func TestInterpretIntegerConversion(t *testing.T) {
 	for _, ty := range sema.AllIntegerTypes {
 		// Only test leaf types
 		switch ty {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 
@@ -891,7 +891,7 @@ func TestInterpretIntegerMinMax(t *testing.T) {
 	for _, ty := range sema.AllIntegerTypes {
 		// Only test leaf types
 		switch ty {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 

runtime/tests/interpreter/interpreter_test.go

@@ -7469,7 +7469,7 @@ func TestInterpretEmitEventParameterTypes(t *testing.T) {
 	for _, integerType := range sema.AllIntegerTypes {
 
 		switch integerType {
-		case sema.IntegerType, sema.SignedIntegerType:
+		case sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType:
 			continue
 		}
 

types.go

@@ -438,7 +438,7 @@ func NewUnsignedIntegerType() FixedSizeUnsignedIntegerType {
 func (FixedSizeUnsignedIntegerType) isType() {}
 
 func (FixedSizeUnsignedIntegerType) ID() string {
-	return "FixedSizedUnsignedInteger"
+	return "FixedSizeUnsignedInteger"
 }
 
 func (t FixedSizeUnsignedIntegerType) Equal(other Type) bool {

values_test.go

@@ -655,7 +655,7 @@ func TestNumberValue_ToBigEndianBytes(t *testing.T) {
 	for _, integerType := range sema.AllNumberTypes {
 		switch integerType {
 		case sema.NumberType, sema.SignedNumberType,
-			sema.IntegerType, sema.SignedIntegerType,
+			sema.IntegerType, sema.SignedIntegerType, sema.FixedSizeUnsignedIntegerType,
 			sema.FixedPointType, sema.SignedFixedPointType:
 			continue
 		}