Extended debug

languageserver/go.sum

@@ -439,6 +439,7 @@ golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapK
 golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
 golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200323144430-8dcfad9e016e/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
 golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
 golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=

runtime/errors.go

@@ -25,6 +25,7 @@ import (
 	"github.com/onflow/cadence/runtime/errors"
 	"github.com/onflow/cadence/runtime/interpreter"
 	"github.com/onflow/cadence/runtime/sema"
+	"github.com/onflow/cadence/runtime/stdlib"
 )
 
 // Error is the containing type for all errors produced by the runtime.
@@ -216,3 +217,29 @@ func (e *TransactionParameterTypeNotStorableError) Error() string {
 		e.Type.QualifiedString(),
 	)
 }
+
+// ExtendedParsingCheckingError is a special error which aids in debugging checking problems
+// by providing extra information about the state of the environment
+// Separate package to prevent cyclic imports with checker tests
+type ExtendedParsingCheckingError struct {
+	Err            error
+	RuntimeStorage *InterpreterRuntimeStorage
+	Functions      stdlib.StandardLibraryFunctions
+	Code           []byte
+	Location       Location
+	Options        []sema.Option
+	UseCache       bool
+	Checker        *sema.Checker
+}
+
+func (e *ExtendedParsingCheckingError) ChildErrors() []error {
+	return []error{e.Err}
+}
+
+func (e *ExtendedParsingCheckingError) Error() string {
+	return e.Err.Error()
+}
+
+func (e ExtendedParsingCheckingError) Unwrap() error {
+	return e.Err
+}

runtime/runtime.go

@@ -298,6 +298,13 @@ func (r *interpreterRuntime) ExecuteTransaction(
 
 	checker, err := r.parseAndCheckProgram(script, runtimeInterface, location, functions, nil, false)
 	if err != nil {
+		ee, is := err.(*ExtendedParsingCheckingError)
+		if is {
+			ee.RuntimeStorage = runtimeStorage
+			ee.Functions = functions
+			//return newError(ee.Err)
+			return newError(ee)
+		}
 		return newError(err)
 	}
 
@@ -516,21 +523,42 @@ func (r *interpreterRuntime) parseAndCheckProgram(
 			program, err = runtimeInterface.GetCachedProgram(location)
 		})
 		if err != nil {
-			return nil, err
+			return nil, &ExtendedParsingCheckingError{
+				Err:       err,
+				Code:      code,
+				Location:  location,
+				Functions: functions,
+				Options:   options,
+				UseCache:  useCache,
+			}
 		}
 	}
 
 	if program == nil {
 		program, err = r.parse(location, code, runtimeInterface)
 		if err != nil {
-			return nil, err
+			return nil, &ExtendedParsingCheckingError{
+				Err:       err,
+				Code:      code,
+				Location:  location,
+				Functions: functions,
+				Options:   options,
+				UseCache:  useCache,
+			}
 		}
 	}
 
 	importResolver := r.importResolver(runtimeInterface)
 	err = program.ResolveImports(importResolver)
 	if err != nil {
-		return nil, err
+		return nil, &ExtendedParsingCheckingError{
+			Err:       err,
+			Code:      code,
+			Location:  location,
+			Functions: functions,
+			Options:   options,
+			UseCache:  useCache,
+		}
 	}
 
 	valueDeclarations := functions.ToValueDeclarations()
@@ -568,12 +596,28 @@ func (r *interpreterRuntime) parseAndCheckProgram(
 		)...,
 	)
 	if err != nil {
-		return nil, err
+		return nil, &ExtendedParsingCheckingError{
+			Err:       err,
+			Code:      code,
+			Location:  location,
+			Functions: functions,
+			Options:   options,
+			UseCache:  useCache,
+			Checker:   checker,
+		}
 	}
 
 	err = checker.Check()
 	if err != nil {
-		return nil, err
+		return nil, &ExtendedParsingCheckingError{
+			Err:       err,
+			Code:      code,
+			Location:  location,
+			Functions: functions,
+			Options:   options,
+			UseCache:  useCache,
+			Checker:   checker,
+		}
 	}
 
 	// After the program has passed semantic analysis, cache the program AST.

runtime/runtime_storage.go

@@ -46,6 +46,9 @@ type interpreterRuntimeStorage struct {
 	cache                   map[storageKey]cacheEntry
 }
 
+// temporary export the type for usage in ExtendedParsingCheckingError
+type InterpreterRuntimeStorage = interpreterRuntimeStorage
+
 func newInterpreterRuntimeStorage(runtimeInterface Interface) *interpreterRuntimeStorage {
 	highLevelStorageEnabled := false
 	highLevelStorage, ok := runtimeInterface.(HighLevelStorage)

runtime/runtime_test.go

@@ -39,7 +39,6 @@ import (
 	"github.com/onflow/cadence/runtime/interpreter"
 	"github.com/onflow/cadence/runtime/sema"
 	"github.com/onflow/cadence/runtime/stdlib"
-	"github.com/onflow/cadence/runtime/tests/checker"
 	"github.com/onflow/cadence/runtime/tests/utils"
 )
 
@@ -2377,7 +2376,14 @@ func TestRuntimeCyclicImport(t *testing.T) {
 
 	require.Error(t, err)
 	require.IsType(t, Error{}, err)
-	assert.IsType(t, ast.CyclicImportsError{}, err.(Error).Unwrap())
+
+	// Temporary to help catch checking error
+	ee := err.(Error).Unwrap()
+
+	require.IsType(t, &ExtendedParsingCheckingError{}, ee)
+	eee := ee.(*ExtendedParsingCheckingError)
+
+	assert.IsType(t, ast.CyclicImportsError{}, eee.Unwrap())
 }
 
 func ArrayValueFromBytes(bytes []byte) *interpreter.ArrayValue {
@@ -3338,7 +3344,7 @@ func TestRuntimeTransactionTopLevelDeclarations(t *testing.T) {
 		require.IsType(t, Error{}, err)
 		err = err.(Error).Unwrap()
 
-		errs := checker.ExpectCheckerErrors(t, err, 1)
+		errs := ExpectCheckerErrors(t, err, 1)
 
 		assert.IsType(t, &sema.InvalidTopLevelDeclarationError{}, errs[0])
 	})
@@ -4774,3 +4780,38 @@ func TestRuntime(t *testing.T) {
 		test(testCase)
 	}
 }
+
+// Copied to prevent import cycle while importing from tests/checker package
+// while using ExtendedParsingCheckingError
+// This now required `runtime` to get access `ExtendedParsingCheckingError`
+// which in turns requires `runtime` so any import of original function from
+// any other module will introduce cycle
+// If we decide to keep extended debug functionality beyond original
+// debug possible race condition, this would need to be refactored
+func ExpectCheckerErrors(t *testing.T, err error, count int) []error {
+	if count <= 0 && err == nil {
+		return nil
+	}
+
+	require.Error(t, err)
+
+	// Temporary to help catch checking error
+	ee, is := err.(*ExtendedParsingCheckingError)
+	if is {
+		err = ee.Unwrap()
+	}
+
+	assert.IsType(t, &sema.CheckerError{}, err)
+
+	errs := err.(*sema.CheckerError).Errors
+
+	require.Len(t, errs, count)
+
+	// Get the error message, to check that it can be successfully generated
+
+	for _, checkerErr := range errs {
+		_ = checkerErr.Error()
+	}
+
+	return errs
+}

runtime/tests/checker/utils.go

@@ -24,6 +24,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/onflow/cadence/runtime"
 	"github.com/onflow/cadence/runtime/ast"
 	"github.com/onflow/cadence/runtime/errors"
 	"github.com/onflow/cadence/runtime/parser2"
@@ -92,6 +93,12 @@ func ExpectCheckerErrors(t *testing.T, err error, count int) []error {
 
 	require.Error(t, err)
 
+	// Temporary to help catch checking error
+	ee, is := err.(*runtime.ExtendedParsingCheckingError)
+	if is {
+		err = ee.Unwrap()
+	}
+
 	assert.IsType(t, &sema.CheckerError{}, err)
 
 	errs := err.(*sema.CheckerError).Errors