call constructor for contracts loaded from identifier location, test

Author: turbolent

runtime/environment.go

@@ -1092,30 +1092,48 @@ func (e *interpreterEnvironment) newCompositeValueFunctionsHandler() interpreter
 func (e *interpreterEnvironment) loadContract(
 	inter *interpreter.Interpreter,
 	compositeType *sema.CompositeType,
-	_ func(common.Address) *interpreter.HostFunctionValue,
-	_ ast.Range,
+	constructorGenerator func(common.Address) *interpreter.HostFunctionValue,
+	invocationRange ast.Range,
 ) *interpreter.CompositeValue {
 
-	var storedValue interpreter.Value
+	var contractValue interpreter.Value
+
+	location := compositeType.Location
+	switch location := location.(type) {
+	case common.IdentifierLocation:
+		// Identifier locations are used for built-in contracts,
+		// and are not stored in storage
+
+		constructorGenerator := constructorGenerator(common.ZeroAddress)
+		var err error
+		contractValue, err = inter.InvokeFunctionValue(
+			constructorGenerator,
+			nil,
+			nil,
+			nil,
+			compositeType,
+			invocationRange,
+		)
+		if err != nil {
+			panic(err)
+		}
 
-	switch location := compositeType.Location.(type) {
-	// TODO: support e.g. CryptoContractLocation
 	case common.AddressLocation:
 		storageMap := e.storage.GetStorageMap(
 			location.Address,
 			StorageDomainContract,
 			false,
 		)
 		if storageMap != nil {
-			storedValue = storageMap.ReadValue(inter, interpreter.StringStorageMapKey(location.Name))
+			contractValue = storageMap.ReadValue(inter, interpreter.StringStorageMapKey(location.Name))
 		}
 	}
 
-	if storedValue == nil {
-		panic(errors.NewDefaultUserError("failed to load contract: %s", compositeType.Location))
+	if contractValue == nil {
+		panic(errors.NewDefaultUserError("failed to load contract: %s", location))
 	}
 
-	return storedValue.(*interpreter.CompositeValue)
+	return contractValue.(*interpreter.CompositeValue)
 }
 
 func (e *interpreterEnvironment) newOnFunctionInvocationHandler() func(_ *interpreter.Interpreter) {

runtime/runtime_test.go

@@ -11561,3 +11561,101 @@ func TestResultRedeclared(t *testing.T) {
 	})
 
 }
+func TestRuntimeContractValueLocation(t *testing.T) {
+
+	t.Parallel()
+
+	signerAddress := common.MustBytesToAddress([]byte{0x42})
+
+	const fooContractName = "Foo"
+	fooIdentifierLocation := common.IdentifierLocation(fooContractName)
+
+	fooContract := []byte(`
+      access(all)
+      contract Foo {
+          access(all) var answer: Int
+
+          init() {
+              self.answer = 42
+          }
+      }
+    `)
+
+	accountCodes := map[Location][]byte{}
+	var events []cadence.Event
+
+	runtimeInterface := &TestRuntimeInterface{
+		Storage: NewTestLedger(nil, nil),
+		OnGetSigningAccounts: func() ([]Address, error) {
+			return []Address{signerAddress}, nil
+		},
+		OnResolveLocation: func(identifiers []Identifier, location Location) ([]ResolvedLocation, error) {
+			assert.Empty(t, identifiers)
+			assert.Equal(t, fooIdentifierLocation, location)
+
+			return []ResolvedLocation{
+				{
+					Location:    location,
+					Identifiers: identifiers,
+				},
+			}, nil
+		},
+		OnGetAccountContractCode: func(location common.AddressLocation) (code []byte, err error) {
+			return accountCodes[location], nil
+		},
+		OnUpdateAccountContractCode: func(location common.AddressLocation, code []byte) error {
+			accountCodes[location] = code
+			return nil
+		},
+		OnEmitEvent: func(event cadence.Event) error {
+			events = append(events, event)
+			return nil
+		},
+		OnGetCode: func(location Location) ([]byte, error) {
+			assert.Equal(t, fooIdentifierLocation, location)
+			return fooContract, nil
+		},
+	}
+
+	runtime := NewTestInterpreterRuntime()
+
+	nextTransactionLocation := NewTransactionLocationGenerator()
+	nextScriptLocation := NewScriptLocationGenerator()
+
+	// Deploy
+
+	deploy := DeploymentTransaction(fooContractName, fooContract)
+
+	err := runtime.ExecuteTransaction(
+		Script{
+			Source: deploy,
+		},
+		Context{
+			Interface: runtimeInterface,
+			Location:  nextTransactionLocation(),
+		},
+	)
+	require.NoError(t, err)
+
+	// Test
+
+	result, err := runtime.ExecuteScript(
+		Script{
+			Source: []byte(`
+              import Foo
+
+              access(all)
+              fun main(): Int {
+                  return Foo.answer
+              }
+            `),
+		},
+		Context{
+			Interface: runtimeInterface,
+			Location:  nextScriptLocation(),
+		},
+	)
+	require.NoError(t, err)
+
+	assert.Equal(t, cadence.NewInt(42), result)
+}