feat: add spans

- Added spans for all parsers and combinators that explicitly return results. - Made some minor improvements here and there.
norskeld · Jan 17, 2023 · 88b13b1 · 88b13b1
1 parent dc23f7f
commit 88b13b1
Show file tree

Hide file tree

Showing 23 changed files with 100 additions and 31 deletions.
diff --git a/src/__tests__/combinators/attempt.spec.ts b/src/__tests__/combinators/attempt.spec.ts
@@ -14,6 +14,7 @@ describe('attempt', () => {
 
     should.beStrictEqual(actual, {
       isOk: true,
+      span: [0, 13],
       pos: 13,
       value: ['hello', 'let', 'lettuce']
     })
@@ -24,6 +25,7 @@ describe('attempt', () => {
 
     should.beStrictEqual(actual, {
       isOk: false,
+      span: [6, 9],
       pos: 9,
       expected: 'lettuce'
     })
@@ -34,6 +36,7 @@ describe('attempt', () => {
 
     should.beStrictEqual(actual, {
       isOk: false,
+      span: [6, 6],
       pos: 6,
       expected: 'let'
     })

diff --git a/src/__tests__/combinators/lookahead.spec.ts b/src/__tests__/combinators/lookahead.spec.ts
@@ -14,6 +14,7 @@ describe('lookahead', () => {
 
     should.beStrictEqual(actual, {
       isOk: true,
+      span: [0, 13],
       pos: 13,
       value: ['hello', 'let', 'lettuce']
     })
@@ -24,6 +25,7 @@ describe('lookahead', () => {
 
     should.beStrictEqual(actual, {
       isOk: false,
+      span: [6, 9],
       pos: 9,
       expected: 'lettuce'
     })
@@ -34,6 +36,7 @@ describe('lookahead', () => {
 
     should.beStrictEqual(actual, {
       isOk: false,
+      span: [6, 9],
       pos: 9,
       expected: 'let'
     })

diff --git a/src/__tests__/parsers/tryRun.spec.ts b/src/__tests__/parsers/tryRun.spec.ts
@@ -16,7 +16,7 @@ describe('tryRun', () => {
     deferred.with(string('deferred'))
 
     const actual = () => tryRun(deferred).with('lazy')
-    const expected = new ParserError({ pos: 8, expected: 'deferred' })
+    const expected = new ParserError({ pos: 8, span: [0, 4], expected: 'deferred' })
 
     should.throwError(actual, expected)
   })

diff --git a/src/combinators/attempt.ts b/src/combinators/attempt.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Applies `parser` without consuming any input. It doesn't care if `parser` succeeds or fails, it
@@ -18,6 +18,7 @@ export function attempt<T>(parser: Parser<T>): Parser<T> {
         case true: {
           return {
             isOk: true,
+            span: [pos, pos] as Span,
             pos,
             value: result.value
           }
@@ -27,6 +28,7 @@ export function attempt<T>(parser: Parser<T>): Parser<T> {
         case false: {
           return {
             isOk: false,
+            span: [pos, pos] as Span,
             pos,
             expected: result.expected
           }

diff --git a/src/combinators/error.ts b/src/combinators/error.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Replaces `parser`'s error message with `expected`.
@@ -21,6 +21,7 @@ export function error<T>(parser: Parser<T>, expected: string): Parser<T> {
         case false: {
           return {
             isOk: false,
+            span: [pos, result.pos] as Span,
             pos,
             expected
           }

diff --git a/src/combinators/lookahead.ts b/src/combinators/lookahead.ts
@@ -18,6 +18,7 @@ export function lookahead<T>(parser: Parser<T>): Parser<T> {
         case true: {
           return {
             isOk: true,
+            span: result.span,
             pos,
             value: result.value
           }

diff --git a/src/combinators/many.ts b/src/combinators/many.ts
@@ -1,4 +1,4 @@
-import type { Parser, SafeParser } from '@types'
+import type { Parser, SucceedingParser, Span } from '@types'
 
 /**
  * Applies `parser` *zero* or more times, collecting its results. Never fails.
@@ -7,7 +7,7 @@ import type { Parser, SafeParser } from '@types'
  *
  * @returns Array of the returned values of `parser`
  */
-export function many<T>(parser: Parser<T>): SafeParser<Array<T>> {
+export function many<T>(parser: Parser<T>): SucceedingParser<Array<T>> {
   return {
     parse(input, pos) {
       const values: Array<T> = []
@@ -26,6 +26,7 @@ export function many<T>(parser: Parser<T>): SafeParser<Array<T>> {
 
       return {
         isOk: true,
+        span: [pos, nextPos] as Span,
         pos: nextPos,
         value: values
       }
@@ -65,6 +66,7 @@ export function many1<T>(parser: Parser<T>): Parser<Array<T>> {
 
         return {
           isOk: true,
+          span: [pos, nextPos] as Span,
           pos: nextPos,
           value: values
         }

diff --git a/src/combinators/map.ts b/src/combinators/map.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Applies `fn` to the `parser`'s result.
@@ -8,17 +8,20 @@ import type { Parser } from '@types'
  *
  * @returns Result of `fn`
  */
-export function map<T, R>(parser: Parser<T>, fn: (value: T) => R): Parser<R> {
+export function map<T, R>(parser: Parser<T>, fn: (value: T, span: Span) => R): Parser<R> {
   return {
     parse(input, pos) {
       const result = parser.parse(input, pos)
 
       switch (result.isOk) {
         case true: {
+          const span = [pos, result.pos] as Span
+
           return {
             isOk: true,
+            span,
             pos: result.pos,
-            value: fn(result.value)
+            value: fn(result.value, span)
           }
         }
 

diff --git a/src/combinators/sepBy.ts b/src/combinators/sepBy.ts
@@ -1,7 +1,7 @@
 import { many } from './many'
 import { sequence } from './sequence'
 
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Parses *zero* or more occurrences of `parser`, separated by `sep`. Never fails.
@@ -23,17 +23,21 @@ export function sepBy<T, S>(parser: Parser<T>, sep: Parser<S>): Parser<Array<T>>
         const values = [resultP.value]
 
         // If the parsers succeed, concatenate the values sans the separator.
-        resultS.value.forEach(([, value]) => values.push(value))
+        for (const [, value] of resultS.value) {
+          values.push(value)
+        }
 
         return {
           isOk: true,
+          span: [pos, resultS.pos] as Span,
           pos: resultS.pos,
           value: values
         }
       }
 
       return {
         isOk: true,
+        span: [pos, resultP.pos] as Span,
         pos: resultP.pos,
         value: []
       }
@@ -61,17 +65,21 @@ export function sepBy1<T, S>(parser: Parser<T>, sep: Parser<S>): Parser<Array<T>
         const values = [resultP.value]
 
         // If the parsers succeed, concatenate the values sans the separator.
-        resultS.value.forEach(([, value]) => values.push(value))
+        for (const [, value] of resultS.value) {
+          values.push(value)
+        }
 
         return {
           isOk: true,
+          span: [pos, resultS.pos] as Span,
           pos: resultS.pos,
           value: values
         }
       }
 
       return {
         isOk: false,
+        span: [pos, resultP.pos] as Span,
         pos: resultP.pos,
         expected: resultP.expected
       }

diff --git a/src/combinators/sequence.ts b/src/combinators/sequence.ts
@@ -1,4 +1,4 @@
-import type { Parser, ToTuple } from '@types'
+import type { Parser, Span, ToTuple } from '@types'
 
 /**
  * Applies `ps` parsers in order, until *all* of them succeed.
@@ -32,6 +32,7 @@ export function sequence<T>(...ps: Array<Parser<T>>): Parser<Array<T>> {
 
       return {
         isOk: true,
+        span: [pos, nextPos] as Span,
         pos: nextPos,
         value: values
       }

diff --git a/src/combinators/until.ts b/src/combinators/until.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Applies source `parser`, collects its output, and stops after `terminator` parser succeeds.
@@ -23,6 +23,7 @@ export function takeUntil<T, S>(parser: Parser<T>, terminator: Parser<S>): Parse
           case true: {
             return {
               isOk: true,
+              span: [pos, resultT.pos] as Span,
               pos: resultT.pos,
               value: [values, resultT.value]
             }
@@ -68,6 +69,7 @@ export function skipUntil<T, S>(parser: Parser<T>, terminator: Parser<S>): Parse
           case true: {
             return {
               isOk: true,
+              span: [pos, resultT.pos] as Span,
               pos: resultT.pos,
               value: resultT.value
             }

diff --git a/src/parsers/any.ts b/src/parsers/any.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Parses any single character from the input and returns it. Fails at the end of input.
@@ -11,6 +11,7 @@ export function any(): Parser<string> {
       if (input.length === pos) {
         return {
           isOk: false,
+          span: [pos, pos] as Span,
           pos,
           expected: 'any @ reached the end of input'
         }
@@ -21,6 +22,7 @@ export function any(): Parser<string> {
 
       return {
         isOk: true,
+        span: [pos, nextPos] as Span,
         pos: nextPos,
         value
       }

diff --git a/src/parsers/defer.ts b/src/parsers/defer.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Intersection type to add a method for deferred parser definition.
@@ -71,6 +71,7 @@ export function defer<T>(): Deferred<T> {
 
       return {
         isOk: false,
+        span: [pos, pos] as Span,
         pos,
         expected: `Deferred parser wasn't initialized.`
       }

diff --git a/src/parsers/eof.ts b/src/parsers/eof.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Only succeeds at the end of the input.
@@ -8,12 +8,11 @@ import type { Parser } from '@types'
 export function eof(): Parser<null> {
   return {
     parse(input, pos) {
-      const isEof = pos === input.length
-
-      switch (isEof) {
+      switch (pos === input.length) {
         case true: {
           return {
             isOk: true,
+            span: [pos, pos] as Span,
             pos: input.length,
             value: null
           }
@@ -22,6 +21,7 @@ export function eof(): Parser<null> {
         case false: {
           return {
             isOk: false,
+            span: [pos, pos] as Span,
             pos,
             expected: 'end of input'
           }

diff --git a/src/parsers/noneOf.ts b/src/parsers/noneOf.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Ensures that none of the characters in the given string matches the current character.
@@ -15,6 +15,7 @@ export function noneOf(chars: string): Parser<string> {
       if (input.length === pos) {
         return {
           isOk: false,
+          span: [pos, pos] as Span,
           pos,
           expected: 'noneOf @ reached the end of input'
         }
@@ -26,14 +27,16 @@ export function noneOf(chars: string): Parser<string> {
       if (!charset.includes(char)) {
         return {
           isOk: true,
+          span: [pos, nextPos] as Span,
           pos: nextPos,
           value: char
         }
       }
 
       return {
         isOk: false,
-        pos,
+        span: [pos, pos] as Span,
+        pos: nextPos,
         expected: `none of: ${charset.join(', ')}`
       }
     }

diff --git a/src/parsers/nothing.ts b/src/parsers/nothing.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '@types'
+import type { Parser, Span } from '@types'
 
 /**
  * Simply resolves to `null`.
@@ -10,6 +10,7 @@ export function nothing(): Parser<null> {
     parse(_, pos) {
       return {
         isOk: true,
+        span: [pos, pos] as Span,
         pos,
         value: null
       }