handle new Crypto contract and import location resolution

languageserver/run.sh

@@ -4,8 +4,7 @@ SCRIPTPATH=$(dirname "$0")
 
 if [ "$1" = "cadence" ] && [ "$2" = "language-server" ] ; then
 	(cd "$SCRIPTPATH" && \
-		go build -gcflags="all=-N -l" ./cmd/languageserver && \
-		dlv --log-dest 2 --continue --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec ./languageserver -- "$@");
+		go run -gcflags="all=-N -l" ./cmd/languageserver --enable-flow-client=false);
 else
 	flow "$@"
 fi

test/emulator_backend.go

@@ -22,6 +22,7 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
+	"sort"
 	"strings"
 	"time"
 
@@ -43,6 +44,7 @@ import (
 	"github.com/onflow/flow-go-sdk/crypto"
 	sdkTest "github.com/onflow/flow-go-sdk/test"
 	fvmCrypto "github.com/onflow/flow-go/fvm/crypto"
+	"github.com/onflow/flow-go/fvm/environment"
 	"github.com/onflow/flow-go/fvm/systemcontracts"
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/rs/zerolog"
@@ -102,6 +104,9 @@ type EmulatorBackend struct {
 	// contracts is a mapping of contract identifiers to their
 	// deployed account address.
 	contracts map[string]common.Address
+
+	// locationHandler is used for resolving locations
+	locationHandler sema.LocationHandlerFunc
 }
 
 type keyInfo struct {
@@ -110,11 +115,12 @@ type keyInfo struct {
 }
 
 var chain = flow.MonotonicEmulator.Chain()
+var chainContracts = systemcontracts.SystemContractsForChain(chain.ChainID())
 
 var commonContracts = emulator.NewCommonContracts(chain)
 
+// TODO: refactor, use chainContracts.All instead
 var systemContracts = func() []common.AddressLocation {
-	chainContracts := systemcontracts.SystemContractsForChain(chain.ChainID())
 	serviceAddress := chain.ServiceAddress().HexWithPrefix()
 	contracts := map[string]string{
 		"FlowServiceAccount":         serviceAddress,
@@ -138,6 +144,7 @@ var systemContracts = func() []common.AddressLocation {
 		"EVM":                        serviceAddress,
 		"FungibleTokenSwitchboard":   chainContracts.FungibleToken.Address.HexWithPrefix(),
 		"Burner":                     serviceAddress,
+		"Crypto":                     serviceAddress,
 	}
 
 	locations := make([]common.AddressLocation, 0)
@@ -175,21 +182,55 @@ func NewEmulatorBackend(
 	clock := newSystemClock()
 	blockchain.SetClock(clock)
 
+	sc := systemcontracts.SystemContractsForChain(chain.ChainID())
+	cryptoContractAddress := common.Address(sc.Crypto.Address)
+
+	locationHandler := func(
+		identifiers []ast.Identifier,
+		location common.Location,
+	) ([]sema.ResolvedLocation, error) {
+		return environment.ResolveLocation(
+			identifiers,
+			location,
+			func(address flow.Address) ([]string, error) {
+				return accountContractNames(blockchain, address)
+			},
+			cryptoContractAddress,
+		)
+	}
+
 	emulatorBackend := &EmulatorBackend{
-		blockchain:    blockchain,
-		blockOffset:   0,
-		accountKeys:   map[common.Address]map[string]keyInfo{},
-		stdlibHandler: stdlibHandler,
-		logCollection: logCollectionHook,
-		clock:         clock,
-		contracts:     map[string]common.Address{},
-		accounts:      map[common.Address]*stdlib.Account{},
+		blockchain:      blockchain,
+		blockOffset:     0,
+		accountKeys:     map[common.Address]map[string]keyInfo{},
+		stdlibHandler:   stdlibHandler,
+		logCollection:   logCollectionHook,
+		clock:           clock,
+		contracts:       map[string]common.Address{},
+		accounts:        map[common.Address]*stdlib.Account{},
+		locationHandler: locationHandler,
 	}
 	emulatorBackend.bootstrapAccounts()
 
 	return emulatorBackend
 }
 
+func accountContractNames(blockchain *emulator.Blockchain, address flow.Address) ([]string, error) {
+	account, err := blockchain.GetAccount(address)
+	if err != nil {
+		return nil, err
+	}
+
+	contractNames := make([]string, 0, len(account.Contracts))
+
+	for name := range account.Contracts {
+		contractNames = append(contractNames, name)
+	}
+	sort.Strings(contractNames)
+
+	return contractNames, nil
+}
+
 func (e *EmulatorBackend) RunScript(
 	inter *interpreter.Interpreter,
 	code string,
@@ -241,6 +282,7 @@ func (e *EmulatorBackend) RunScript(
 		inter,
 		interpreter.EmptyLocationRange,
 		e.stdlibHandler,
+		e.locationHandler,
 		result.Value,
 		expectedType,
 	)
@@ -559,6 +601,7 @@ func (e *EmulatorBackend) Events(
 				inter,
 				interpreter.EmptyLocationRange,
 				e.stdlibHandler,
+				e.locationHandler,
 				event.Value,
 				nil,
 			)

test/test_framework_test.go

@@ -4250,6 +4250,8 @@ func TestCoverageReportForUnitTests(t *testing.T) {
 			"s.7465737400000000000000000000000000000000000000000000000000000000",
 			"A.0000000000000002.FungibleTokenSwitchboard",
 			"A.0000000000000001.Burner",
+			"A.0000000000000001.Crypto",
+			"A.0000000000000001.NFTStorefrontV2",
 		},
 		coverageReport.ExcludedLocationIDs(),
 	)
@@ -4475,6 +4477,8 @@ func TestCoverageReportForIntegrationTests(t *testing.T) {
 			"A.0000000000000001.EVM",
 			"A.0000000000000002.FungibleTokenSwitchboard",
 			"A.0000000000000001.Burner",
+			"A.0000000000000001.NFTStorefrontV2",
+			"A.0000000000000001.Crypto",
 		},
 		coverageReport.ExcludedLocationIDs(),
 	)

test/test_runner.go

@@ -480,7 +480,7 @@ func (r *TestRunner) initializeEnvironment() (
 		Environment: env,
 	}
 	if r.coverageReport != nil {
-		r.coverageReport.ExcludeLocation(stdlib.CryptoCheckerLocation)
+		r.coverageReport.ExcludeLocation(stdlib.CryptoContractLocation)
 		r.coverageReport.ExcludeLocation(stdlib.TestContractLocation)
 		r.coverageReport.ExcludeLocation(helpers.BlockchainHelpersLocation)
 		r.coverageReport.ExcludeLocation(testScriptLocation)
@@ -522,9 +522,6 @@ func (r *TestRunner) checkerImportHandler(ctx runtime.Context) sema.ImportHandle
 	) (sema.Import, error) {
 		var elaboration *sema.Elaboration
 		switch importedLocation {
-		case stdlib.CryptoCheckerLocation:
-			cryptoChecker := stdlib.CryptoChecker()
-			elaboration = cryptoChecker.Elaboration
 
 		case stdlib.TestContractLocation:
 			testChecker := stdlib.GetTestContractType().Checker
@@ -586,17 +583,6 @@ func (r *TestRunner) interpreterContractValueHandler(
 	) interpreter.ContractValue {
 
 		switch compositeType.Location {
-		case stdlib.CryptoCheckerLocation:
-			contract, err := stdlib.NewCryptoContract(
-				inter,
-				constructorGenerator(common.Address{}),
-				invocationRange,
-			)
-			if err != nil {
-				panic(err)
-			}
-			return contract
-
 		case stdlib.TestContractLocation:
 			contract, err := stdlib.GetTestContractType().
 				NewTestContract(
@@ -678,9 +664,6 @@ func (r *TestRunner) interpreterImportHandler(ctx runtime.Context) interpreter.I
 	return func(inter *interpreter.Interpreter, location common.Location) interpreter.Import {
 		var program *interpreter.Program
 		switch location {
-		case stdlib.CryptoCheckerLocation:
-			cryptoChecker := stdlib.CryptoChecker()
-			program = interpreter.ProgramFromChecker(cryptoChecker)
 
 		case stdlib.TestContractLocation:
 			testChecker := stdlib.GetTestContractType().Checker
@@ -765,13 +748,6 @@ func (r *TestRunner) parseAndCheckImport(
 				Elaboration: elaboration,
 			}, nil
 
-		case stdlib.CryptoCheckerLocation:
-			cryptoChecker := stdlib.CryptoChecker()
-			elaboration := cryptoChecker.Elaboration
-			return sema.ElaborationImport{
-				Elaboration: elaboration,
-			}, nil
-
 		default:
 			addressLoc, ok := importedLocation.(common.AddressLocation)
 			if !ok {