Always return parser errors gracefully

runtime/environment.go

@@ -522,9 +522,15 @@ func (e *interpreterEnvironment) parseAndCheckProgram(
  err error,
 ) {
  wrapParsingCheckingError := func(err error) error {
- return &ParsingCheckingError{
- Err: err,
- Location: location,
+ switch err.(type) {
+ // Wrap only parsing and checking errors.
+ case *sema.CheckerError, parser.Error:
+ return &ParsingCheckingError{
+ Err: err,
+ Location: location,
+ }
+ default:
+ return err
  }
  }
 

runtime/error_test.go

@@ -59,6 +59,7 @@ func TestRuntimeError(t *testing.T) {
  Location: location,
  },
  )
+
  require.EqualError(
  t,
  err,

runtime/old_parser/parser.go

@@ -91,8 +91,13 @@ func Parse[T any](
  config Config,
 ) (result T, errors []error) {
  // create a lexer, which turns the input string into tokens
- tokens := lexer.Lex(input, memoryGauge)
+ tokens, err := lexer.Lex(input, memoryGauge)
+ if err != nil {
+ errors = append(errors, err)
+ return
+ }
  defer tokens.Reclaim()
+
  return ParseTokenStream(
  memoryGauge,
  tokens,
@@ -637,8 +642,12 @@ func ParseArgumentList(
 }
 
 func ParseProgram(memoryGauge common.MemoryGauge, code []byte, config Config) (program *ast.Program, err error) {
- tokens := lexer.Lex(code, memoryGauge)
+ tokens, err := lexer.Lex(code, memoryGauge)
+ if err != nil {
+ return
+ }
  defer tokens.Reclaim()
+
  return ParseProgramFromTokenStream(memoryGauge, tokens, config)
 }
 

runtime/old_parser/parser_test.go

@@ -732,18 +732,11 @@ func TestParseArgumentList(t *testing.T) {
  gauge := makeLimitingMemoryGauge()
  gauge.Limit(common.MemoryKindTypeToken, 0)
 
- var panicMsg any
- (func() {
- defer func() {
- panicMsg = recover()
- }()
+ _, err := ParseArgumentList(gauge, []byte(`(1, b: true)`), Config{})
+ require.Len(t, err, 1)
+ require.IsType(t, errors.MemoryError{}, err[0])
 
- ParseArgumentList(gauge, []byte(`(1, b: true)`), Config{})
- })()
-
- require.IsType(t, errors.MemoryError{}, panicMsg)
-
- fatalError, _ := panicMsg.(errors.MemoryError)
+ fatalError, _ := err[0].(errors.MemoryError)
  var expectedError limitingMemoryGaugeError
  assert.ErrorAs(t, fatalError, &expectedError)
  })

runtime/parser/expression_test.go

@@ -324,17 +324,11 @@ func TestParseAdvancedExpression(t *testing.T) {
  gauge.debug = true
  gauge.Limit(common.MemoryKindPosition, 11)
 
- var panicMsg any
- (func() {
- defer func() {
- panicMsg = recover()
- }()
- ParseExpression(gauge, []byte("1 < 2"), Config{})
- })()
+ _, errs := ParseExpression(gauge, []byte("1 < 2"), Config{})
+ require.Len(t, errs, 1)
+ require.IsType(t, errors.MemoryError{}, errs[0])
 
- require.IsType(t, errors.MemoryError{}, panicMsg)
-
- fatalError, _ := panicMsg.(errors.MemoryError)
+ fatalError, _ := errs[0].(errors.MemoryError)
  var expectedError limitingMemoryGaugeError
  assert.ErrorAs(t, fatalError, &expectedError)
  })
@@ -346,18 +340,11 @@ func TestParseAdvancedExpression(t *testing.T) {
  gauge := makeLimitingMemoryGauge()
  gauge.Limit(common.MemoryKindIntegerExpression, 1)
 
- var panicMsg any
- (func() {
- defer func() {
- panicMsg = recover()
- }()
-
- ParseExpression(gauge, []byte("1 < 2 > 3"), Config{})
- })()
-
- require.IsType(t, errors.MemoryError{}, panicMsg)
+ _, errs := ParseExpression(gauge, []byte("1 < 2 > 3"), Config{})
+ require.Len(t, errs, 1)
+ require.IsType(t, errors.MemoryError{}, errs[0])
 
- fatalError, _ := panicMsg.(errors.MemoryError)
+ fatalError, _ := errs[0].(errors.MemoryError)
  var expectedError limitingMemoryGaugeError
  assert.ErrorAs(t, fatalError, &expectedError)
  })

runtime/parser/lexer/lexer.go

@@ -144,13 +144,13 @@ var pool = sync.Pool{
  },
 }
 
-func Lex(input []byte, memoryGauge common.MemoryGauge) TokenStream {
+func Lex(input []byte, memoryGauge common.MemoryGauge) (TokenStream, error) {
  l := pool.Get().(*lexer)
  l.clear()
  l.memoryGauge = memoryGauge
  l.input = input
- l.run(rootState)
- return l
+ err := l.run(rootState)
+ return l, err
 }
 
 // run executes the stateFn, which will scan the runes in the input
@@ -162,32 +162,29 @@ func Lex(input []byte, memoryGauge common.MemoryGauge) TokenStream {
 // stateFn is returned, which for example happens when reaching the end of the file.
 //
 // When all stateFn have been executed, an EOF token is emitted.
-func (l *lexer) run(state stateFn) {
+func (l *lexer) run(state stateFn) (err error) {
 
  // catch panic exceptions, emit it to the tokens channel before
  // closing it
  defer func() {
  if r := recover(); r != nil {
- var err error
  switch r := r.(type) {
- case errors.MemoryError, errors.InternalError:
- // fatal errors and internal errors percolates up.
- // Note: not all fatal errors are internal errors.
- // e.g: memory limit exceeding is a fatal error, but also a user error.
- panic(r)
+ // fatal errors and internal errors percolates up.
+ // Note: not all fatal errors are internal errors.
+ // e.g: memory limit exceeding is a fatal error, but also a user error.
  case error:
  err = r
  default:
  err = fmt.Errorf("lexer: %v", r)
  }
-
- l.emitError(err)
  }
  }()
 
  for state != nil {
  state = state(l)
  }
+
+ return
 }
 
 // next decodes the next rune (UTF8 character) from the input string.

runtime/parser/lexer/lexer_test.go

@@ -63,7 +63,10 @@ func testLex(t *testing.T, input string, expected []token) {
 
  bytes := []byte(input)
 
- withTokens(Lex(bytes, nil), func(actualTokens []Token) {
+ tokenStream, err := Lex(bytes, nil)
+ require.NoError(t, err)
+
+ withTokens(tokenStream, func(actualTokens []Token) {
  utils.AssertEqualWithDiff(t, expectedTokens, actualTokens)
 
  require.Len(t, actualTokens, len(expectedTokens))
@@ -2385,7 +2388,8 @@ func TestRevert(t *testing.T) {
 
  t.Parallel()
 
- tokenStream := Lex([]byte("1 2 3"), nil)
+ tokenStream, err := Lex([]byte("1 2 3"), nil)
+ require.NoError(t, err)
 
  // Assert all tokens
 
@@ -2550,7 +2554,8 @@ func TestEOFsAfterError(t *testing.T) {
 
  t.Parallel()
 
- tokenStream := Lex([]byte(`1 ''`), nil)
+ tokenStream, err := Lex([]byte(`1 ''`), nil)
+ require.NoError(t, err)
 
  // Assert all tokens
 
@@ -2613,7 +2618,8 @@ func TestEOFsAfterEmptyInput(t *testing.T) {
 
  t.Parallel()
 
- tokenStream := Lex(nil, nil)
+ tokenStream, err := Lex(nil, nil)
+ require.NoError(t, err)
 
  // Assert EOFs keep on being returned for Next()
  // at the end of the stream
@@ -2644,10 +2650,6 @@ func TestLimit(t *testing.T) {
 
  code := b.String()
 
- assert.PanicsWithValue(t,
- TokenLimitReachedError{},
- func() {
- _ = Lex([]byte(code), nil)
- },
- )
+ _, err := Lex([]byte(code), nil)
+ require.ErrorAs(t, err, &TokenLimitReachedError{})
 }

runtime/parser/parser.go

@@ -100,8 +100,13 @@
  config Config,
 ) (result T, errors []error) {
  // create a lexer, which turns the input string into tokens
- tokens := lexer.Lex(input, memoryGauge)
+ tokens, err := lexer.Lex(input, memoryGauge)
+ if err != nil {
+ errors = append(errors, err)
+ return
+ }
  defer tokens.Reclaim()
+
  return ParseTokenStream(
  memoryGauge,
  tokens,
@@ -127,29 +132,34 @@
 
  defer func() {
  if r := recover(); r != nil {
+ var err error
  switch r := r.(type) {
  case ParseError:
  // Report parser errors.
  p.report(r)
 
  // Do not treat non-parser errors as syntax errors.
- case errors.InternalError, errors.UserError:
- // Also do not wrap non-parser errors, that are already
- // known cadence errors. i.e: internal errors / user errors.
- // e.g: `errors.MemoryError`
- panic(r)
+ // Also do not wrap non-parser errors, that are already
+ // known cadence errors. i.e: internal errors / user errors.
+ // e.g: `errors.MemoryError`
+ case errors.UserError:
+ err = r
+ case errors.InternalError:
+ err = r
  case error:
  // Any other error/panic is an internal error.
  // Thus, wrap with an UnexpectedError to mark it as an internal error
  // and propagate up the call stack.
- panic(errors.NewUnexpectedErrorFromCause(r))
+ err = errors.NewUnexpectedErrorFromCause(r)
  default:
- panic(errors.NewUnexpectedError("parser: %v", r))
+ err = errors.NewUnexpectedError("parser: %v", r)
  }
 
  var zero T
  result = zero
  errs = p.errors
+
+ errs = append(errs, err)
  }
 
  for _, bufferedErrors := range p.bufferedErrorsStack {
@@ -677,8 +687,12 @@
 }
 
 func ParseProgram(memoryGauge common.MemoryGauge, code []byte, config Config) (program *ast.Program, err error) {
- tokens := lexer.Lex(code, memoryGauge)
+ tokens, err := lexer.Lex(code, memoryGauge)
+ if err != nil {
+ return
+ }
  defer tokens.Reclaim()
+
  return ParseProgramFromTokenStream(memoryGauge, tokens, config)
 }
 

runtime/parser/parser_test.go

@@ -734,18 +734,12 @@ func TestParseArgumentList(t *testing.T) {
  gauge := makeLimitingMemoryGauge()
  gauge.Limit(common.MemoryKindTypeToken, 0)
 
- var panicMsg any
- (func() {
- defer func() {
- panicMsg = recover()
- }()
+ _, errs := ParseArgumentList(gauge, []byte(`(1, b: true)`), Config{})
+ require.Len(t, errs, 1)
 
- ParseArgumentList(gauge, []byte(`(1, b: true)`), Config{})
- })()
+ require.IsType(t, errors.MemoryError{}, errs[0])
 
- require.IsType(t, errors.MemoryError{}, panicMsg)
-
- fatalError, _ := panicMsg.(errors.MemoryError)
+ fatalError, _ := errs[0].(errors.MemoryError)
  var expectedError limitingMemoryGaugeError
  assert.ErrorAs(t, fatalError, &expectedError)
  })

runtime/repl.go

@@ -254,8 +254,11 @@
  code = prefixedCode
  }
 
- tokens := lexer.Lex(code, nil)
+ tokens, err := lexer.Lex(code, nil)
  defer tokens.Reclaim()
+ if err != nil {
+ return
+ }
 
  inputIsComplete = isInputComplete(tokens)
 

runtime/runtime_test.go

@@ -7497,7 +7497,7 @@ func TestRuntimeInternalErrors(t *testing.T) {
 
  RequireError(t, err)
 
- assertRuntimeErrorIsInternalError(t, err)
+ assertRuntimeErrorIsExternalError(t, err)
  })
 
 }