Add Type.address and Type.contractName

runtime/interpreter/value_type.go

@@ -19,6 +19,8 @@
 package interpreter
 
 import (
+	"strings"
+
 	"github.com/onflow/atree"
 
 	"github.com/onflow/cadence/runtime/common"
@@ -172,6 +174,67 @@
 		}
 
 		return AsBoolValue(elaboration.IsRecovered)
+
+	case sema.MetaTypeAddressFieldName:
+		staticType := v.Type
+		if staticType == nil {
+			return Nil
+		}
+
+		location, _, err := common.DecodeTypeID(interpreter, string(staticType.ID()))
+		if err != nil || location == nil {
+			return Nil
+		}
+
+		addressLocation, ok := location.(common.AddressLocation)
+		if !ok {
+			return Nil
+		}
+
+		addressValue := NewAddressValue(
+			interpreter,
+			addressLocation.Address,
+		)
+		return NewSomeValueNonCopying(
+			interpreter,
+			addressValue,
+		)
+
+	case sema.MetaTypeContractNameFieldName:
+		staticType := v.Type
+		if staticType == nil {
+			return Nil
+		}
+
+		location, qualifiedIdentifier, err := common.DecodeTypeID(interpreter, string(staticType.ID()))
+		if err != nil || location == nil {
+			return Nil
+		}
+
+		switch location.(type) {
+		case common.AddressLocation,
+			common.StringLocation:
+
+			separatorIndex := strings.Index(qualifiedIdentifier, ".")
+			contractNameLength := len(qualifiedIdentifier)
+			if separatorIndex >= 0 {
+				contractNameLength = separatorIndex
+			}
+
+			contractNameValue := NewStringValue(
+				interpreter,
+				common.NewStringMemoryUsage(contractNameLength),
+				func() string {
+					return qualifiedIdentifier[0:contractNameLength]
+				},
+			)
+
+			return NewSomeValueNonCopying(interpreter, contractNameValue)
+
+		default:
+			return Nil
+		}
+
 	}
 
 	return nil

runtime/sema/meta_type.go

@@ -69,6 +69,26 @@ const metaTypeIsRecoveredFieldDocString = `
 The type was defined through a recovered program
 `
 
+const MetaTypeAddressFieldName = "address"
+
+var MetaTypeAddressFieldType = &OptionalType{
+	Type: TheAddressType,
+}
+
+const metaTypeAddressFieldDocString = `
+The address of the type, if it was declared in a contract deployed to an account
+`
+
+const MetaTypeContractNameFieldName = "contractName"
+
+var MetaTypeContractNameFieldType = &OptionalType{
+	Type: StringType,
+}
+
+const metaTypeContractNameFieldDocString = `
+The contract name of the type, if it was declared in a contract
+`
+
 func init() {
 	MetaType.Members = func(t *SimpleType) map[string]MemberResolver {
 		return MembersAsResolvers([]*Member{
@@ -90,6 +110,18 @@ func init() {
 				MetaTypeIsRecoveredFieldType,
 				metaTypeIsRecoveredFieldDocString,
 			),
+			NewUnmeteredPublicConstantFieldMember(
+				t,
+				MetaTypeAddressFieldName,
+				MetaTypeAddressFieldType,
+				metaTypeAddressFieldDocString,
+			),
+			NewUnmeteredPublicConstantFieldMember(
+				t,
+				MetaTypeContractNameFieldName,
+				MetaTypeContractNameFieldType,
+				metaTypeContractNameFieldDocString,
+			),
 		})
 	}
 }

runtime/tests/checker/metatype_test.go

@@ -317,6 +317,27 @@ func TestCheckMetaTypeIsRecovered(t *testing.T) {
       let type: Type = Type<Int>()
       let isRecovered: Bool = type.isRecovered
     `)
+	require.NoError(t, err)
+}
+
+func TestCheckMetaTypeAddress(t *testing.T) {
+
+	t.Parallel()
 
+	_, err := ParseAndCheck(t, `
+      let type: Type = Type<Int>()
+      let address: Address = type.address!
+    `)
+	require.NoError(t, err)
+}
+
+func TestCheckMetaTypeContractName(t *testing.T) {
+
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, `
+      let type: Type = Type<Int>()
+      let contractName: String = type.contractName!
+    `)
 	require.NoError(t, err)
 }