[Subtyping Generator] Switch to static-types for runtime subtype checking

bbq/commons/types.go

@@ -46,6 +46,15 @@ func TypeQualifiedName(typ sema.Type, functionName string) string {
 	return typeQualifier + "." + functionName
 }
 
+func StaticTypeQualifiedName(typ interpreter.StaticType, functionName string) string {
+	if typ == nil {
+		return functionName
+	}
+
+	typeQualifier := StaticTypeQualifier(typ)
+	return typeQualifier + "." + functionName
+}
+
 func QualifiedName(typeName, functionName string) string {
 	if typeName == "" {
 		return functionName
@@ -62,6 +71,8 @@ func QualifiedName(typeName, functionName string) string {
 // TODO: Add other types
 // TODO: Maybe make this a method on the type
 func TypeQualifier(typ sema.Type) string {
+	// IMPORTANT: Ensure this is in sync with `StaticTypeQualifier` method below.
+
 	switch typ := typ.(type) {
 	case *sema.ConstantSizedType:
 		return TypeQualifierArrayConstantSized
@@ -95,6 +106,51 @@ func TypeQualifier(typ sema.Type) string {
 	}
 }
 
+func StaticTypeQualifier(typ interpreter.StaticType) string {
+	// IMPORTANT: Ensure this is in sync with `TypeQualifier` method above.
+	// TODO: try to unify
+
+	switch typ := typ.(type) {
+	case *interpreter.ConstantSizedStaticType:
+		return TypeQualifierArrayConstantSized
+	case *interpreter.VariableSizedStaticType:
+		return TypeQualifierArrayVariableSized
+	case *interpreter.DictionaryStaticType:
+		return TypeQualifierDictionary
+	case *interpreter.FunctionStaticType:
+		// This is only applicable for types that also has a constructor with the same name.
+		// e.g: `String` type has the `String()` constructor as well as the type on which
+		// functions can be called (`String.join()`).
+		// Thus, if a constructor function is used as a type-qualifier,
+		// then used the actual type associated with it (i.e: the return type).
+		if typ.TypeFunctionType != nil {
+			return TypeQualifier(typ.TypeFunctionType)
+		}
+		return TypeQualifierFunction
+	case *interpreter.OptionalStaticType:
+		return TypeQualifierOptional
+	case *interpreter.ReferenceStaticType:
+		return StaticTypeQualifier(typ.ReferencedType)
+	case *interpreter.IntersectionStaticType:
+		// TODO: Revisit. Probably this is not needed here?
+		return StaticTypeQualifier(typ.Types[0])
+	case *interpreter.CapabilityStaticType:
+		return interpreter.PrimitiveStaticTypeCapability.String()
+	case *interpreter.InclusiveRangeStaticType:
+		return TypeQualifierInclusiveRange
+
+	// In addition to the `TypeQualifier` method above,
+	// following are needed.
+	case *interpreter.CompositeStaticType:
+		return typ.QualifiedIdentifier
+	case *interpreter.InterfaceStaticType:
+		return typ.QualifiedIdentifier
+
+	default:
+		return typ.String()
+	}
+}
+
 func LocationQualifier(typ sema.Type) string {
 	switch typ := typ.(type) {
 	case *sema.ReferenceType:

bbq/vm/context.go

@@ -331,14 +331,18 @@ func (c *Context) GetMethod(
 ) interpreter.FunctionValue {
 	staticType := value.StaticType(c)
 
-	semaType := c.SemaTypeFromStaticType(staticType)
-
 	var location common.Location
-	if locatedType, ok := semaType.(sema.LocatedType); ok {
-		location = locatedType.GetLocation()
+
+	switch staticType := staticType.(type) {
+	case *interpreter.CompositeStaticType:
+		location = staticType.Location
+	case *interpreter.InterfaceStaticType:
+		location = staticType.Location
+
+		// TODO: Anything else?
 	}
 
-	qualifiedFuncName := commons.TypeQualifiedName(semaType, name)
+	qualifiedFuncName := commons.StaticTypeQualifiedName(staticType, name)
 
 	method := c.GetFunction(location, qualifiedFuncName)
 	if method == nil {
@@ -422,22 +426,26 @@ func (c *Context) DefaultDestroyEvents(resourceValue *interpreter.CompositeValue
 	return eventValues
 }
 
-func (c *Context) SemaTypeFromStaticType(staticType interpreter.StaticType) sema.Type {
-	typeID := staticType.ID()
-	semaType, ok := c.semaTypeCache[typeID]
-	if ok {
-		return semaType
-	}
+func (c *Context) SemaTypeFromStaticType(staticType interpreter.StaticType) (semaType sema.Type) {
+	_, isPrimitiveType := staticType.(interpreter.PrimitiveStaticType)
 
-	// TODO: avoid the sema-type conversion
-	semaType = interpreter.MustConvertStaticToSemaType(staticType, c)
+	if !isPrimitiveType {
+		typeID := staticType.ID()
+		cachedSemaType, ok := c.semaTypeCache[typeID]
+		if ok {
+			return cachedSemaType
+		}
 
-	if c.semaTypeCache == nil {
-		c.semaTypeCache = make(map[sema.TypeID]sema.Type)
+		defer func() {
+			if c.semaTypeCache == nil {
+				c.semaTypeCache = make(map[sema.TypeID]sema.Type)
+			}
+			c.semaTypeCache[typeID] = semaType
+		}()
 	}
-	c.semaTypeCache[typeID] = semaType
 
-	return semaType
+	// TODO: avoid the sema-type conversion
+	return interpreter.MustConvertStaticToSemaType(staticType, c)
 }
 
 func (c *Context) GetContractValue(contractLocation common.AddressLocation) *interpreter.CompositeValue {

bbq/vm/linker.go

@@ -197,16 +197,12 @@ func linkImportedGlobal(
 				contractValue := global.GetValue(context)
 
 				staticType := contractValue.StaticType(context)
-				semaType, err := interpreter.ConvertStaticToSemaType(context, staticType)
-				if err != nil {
-					panic(err)
-				}
 
 				return interpreter.NewEphemeralReferenceValue(
 					context,
 					interpreter.UnauthorizedAccess,
 					contractValue,
-					semaType,
+					staticType,
 				)
 			},
 		)

bbq/vm/reference_tracking.go

@@ -19,12 +19,35 @@
 package vm
 
 import (
+	"sync"
+
 	"github.com/onflow/atree"
 
 	"github.com/onflow/cadence/interpreter"
 )
 
-type ReferencedResourceKindedValues map[atree.ValueID]map[*interpreter.EphemeralReferenceValue]struct{}
+type ReferencedResourceKindedValues map[atree.ValueID]ReferenceSet
+
+type ReferenceSet = map[*interpreter.EphemeralReferenceValue]struct{}
+
+var referenceSetPool = sync.Pool{
+	New: func() any {
+		return ReferenceSet{}
+	},
+}
+
+func newReferenceSet() ReferenceSet {
+	set := referenceSetPool.Get().(ReferenceSet)
+	return set
+}
+
+func releaseReferenceSet(set ReferenceSet) {
+	if set == nil {
+		return
+	}
+	clear(set)
+	referenceSetPool.Put(set)
+}
 
 func (c *Context) MaybeTrackReferencedResourceKindedValue(referenceValue *interpreter.EphemeralReferenceValue) {
 	referenceTrackedValue, ok := referenceValue.Value.(interpreter.ReferenceTrackedResourceKindedValue)
@@ -36,7 +59,7 @@ func (c *Context) MaybeTrackReferencedResourceKindedValue(referenceValue *interp
 
 	values := c.referencedResourceKindedValues[id]
 	if values == nil {
-		values = map[*interpreter.EphemeralReferenceValue]struct{}{}
+		values = newReferenceSet()
 		if c.referencedResourceKindedValues == nil {
 			c.referencedResourceKindedValues = make(ReferencedResourceKindedValues)
 		}
@@ -46,9 +69,11 @@ func (c *Context) MaybeTrackReferencedResourceKindedValue(referenceValue *interp
 }
 
 func (c *Context) ClearReferencedResourceKindedValues(valueID atree.ValueID) {
+	set := c.referencedResourceKindedValues[valueID]
+	releaseReferenceSet(set)
 	delete(c.referencedResourceKindedValues, valueID)
 }
 
-func (c *Context) ReferencedResourceKindedValues(valueID atree.ValueID) map[*interpreter.EphemeralReferenceValue]struct{} {
+func (c *Context) ReferencedResourceKindedValues(valueID atree.ValueID) ReferenceSet {
 	return c.referencedResourceKindedValues[valueID]
 }

bbq/vm/test/ft_test.go

@@ -165,8 +165,8 @@ func compiledFTTransfer(tb testing.TB) {
 		context interpreter.BorrowCapabilityControllerContext,
 		address interpreter.AddressValue,
 		capabilityID interpreter.UInt64Value,
-		wantedBorrowType *sema.ReferenceType,
-		capabilityBorrowType *sema.ReferenceType,
+		wantedBorrowType *interpreter.ReferenceStaticType,
+		capabilityBorrowType *interpreter.ReferenceStaticType,
 	) interpreter.ReferenceValue {
 		return stdlib.BorrowCapabilityController(
 			context,

bbq/vm/test/interpreter_test.go

@@ -323,8 +323,8 @@ func interpreterFTTransfer(tb testing.TB) {
 			context interpreter.BorrowCapabilityControllerContext,
 			address interpreter.AddressValue,
 			capabilityID interpreter.UInt64Value,
-			wantedBorrowType *sema.ReferenceType,
-			capabilityBorrowType *sema.ReferenceType,
+			wantedBorrowType *interpreter.ReferenceStaticType,
+			capabilityBorrowType *interpreter.ReferenceStaticType,
 		) interpreter.ReferenceValue {
 			return stdlib.BorrowCapabilityController(
 				context,

bbq/vm/test/vm_test.go

@@ -11726,7 +11726,11 @@ func TestBorrowContractLinksGlobals(t *testing.T) {
 				context,
 				contractAddress,
 				interpreter.NewUnmeteredStringValue(contractName),
-				sema.NewReferenceType(nil, sema.UnauthorizedAccess, sema.AnyStructType),
+				interpreter.NewReferenceStaticType(
+					nil,
+					interpreter.UnauthorizedAccess,
+					interpreter.PrimitiveStaticTypeAnyStruct,
+				),
 				accountHandler,
 			)
 

bbq/vm/value.go

@@ -31,13 +31,10 @@ func ConvertAndBox(
 	value Value,
 	valueType, targetType bbq.StaticType,
 ) Value {
-	valueSemaType := context.SemaTypeFromStaticType(valueType)
-	targetSemaType := context.SemaTypeFromStaticType(targetType)
-
-	return interpreter.ConvertAndBox(
+	return interpreter.ConvertAndBoxToStaticType(
 		context,
 		value,
-		valueSemaType,
-		targetSemaType,
+		valueType,
+		targetType,
 	)
 }

bbq/vm/value_implicit_reference.go

@@ -47,15 +47,15 @@ func NewImplicitReferenceValue(context interpreter.ReferenceCreationContext, val
 		}
 	}
 
-	semaType := interpreter.MustSemaTypeOfValue(value, context)
+	staticType := value.StaticType(context)
 
 	// Create an explicit reference to represent the implicit reference behavior of 'self' value.
 	// Authorization doesn't matter, we just need a reference to add to tracking.
 	selfRef := interpreter.NewEphemeralReferenceValue(
 		context,
 		interpreter.UnauthorizedAccess,
 		value,
-		semaType,
+		staticType,
 	)
 
 	return ImplicitReferenceValue{

bbq/vm/value_inclusiverange.go

@@ -38,7 +38,7 @@ func init() {
 				if !ok {
 					panic(errors.NewUnreachableError())
 				}
-				elementType := interpreter.MustConvertStaticToSemaType(rangeType.ElementType, context)
+				elementType := context.SemaTypeFromStaticType(rangeType.ElementType)
 				return sema.InclusiveRangeContainsFunctionType(elementType)
 			},
 			interpreter.NativeInclusiveRangeContainsFunction,