@weborigami/language 0.1.0 → 0.2.0

package/src/compiler/origami.pegjs

@@ -2,19 +2,29 @@
 //
 // Origami language parser
 //
+// This generally follows the pattern of the JavaScript expression grammar at
+// https://github.com/pegjs/pegjs/blob/master/examples/javascript.pegjs. Like
+// that parser, this one uses the ECMAScript grammar terms where relevant.
+//
 // Generate the parser via `npm build`.
+//
 // @ts-nocheck
 //
 
 import * as ops from "../runtime/ops.js";
 import {
   annotate,
+  downgradeReference,
   makeArray,
-  makeFunctionCall,
+  makeBinaryOperatorChain,
+  makeCall,
+  makeDeferredArguments,
   makeObject,
   makePipeline,
   makeProperty,
-  makeTemplate
+  makeReference,
+  makeTemplate,
+  makeUnaryOperatorCall
 } from "./parserHelpers.js";
 
 }}
@@ -25,21 +35,12 @@ __
     return null;
   }
 
-// A filesystem path that begins with a slash: `/foo/bar`
-// We take care to avoid treating two consecutive leading slashes as a path;
-// that starts a comment.
-absoluteFilePath "absolute file path"
-  = !"//" path:leadingSlashPath {
-      return annotate([[ops.filesRoot], ...path], location());
-    }
-
-args "function arguments"
-  = parensArgs
-  / path:leadingSlashPath {
-      return annotate([ops.traverse, ...path], location());
-    }
+arguments "function arguments"
+  = parenthesesArguments
+  / pathArguments
+  / templateLiteral
 
-array "array"
+arrayLiteral "array"
   = "[" __ entries:arrayEntries? __ closingBracket {
       return annotate(makeArray(entries ?? []), location());
     }
@@ -52,19 +53,22 @@ arrayEntries
 
 arrayEntry
   = spread
-  / pipeline
-
-// Something that can be called. This is more restrictive than the `value`
-// parser; it doesn't accept regular function calls.
-callTarget "function call"
-  = absoluteFilePath
-  / scopeTraverse
-  / array
-  / object
-  / group
-  / namespacePath
-  / namespace
-  / functionReference
+  / pipelineExpression
+
+arrowFunction
+  = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ pipeline:pipelineExpression {
+      return annotate([ops.lambda, parameters ?? [], pipeline], location());
+    }
+  / conditionalExpression
+
+// A function call: `fn(arg)`, possibly part of a chain of function calls, like
+// `fn(arg1)(arg2)(arg3)`.
+callExpression "function call"
+  = head:protocolExpression tail:arguments* {
+      return tail.length === 0
+        ? head
+        : annotate(tail.reduce(makeCall, head), location());
+    }
 
 // Required closing curly brace. We use this for the `object` term: if the
 // parser sees a left curly brace, here we must see a right curly brace.
@@ -84,7 +88,7 @@ closingBracket
 // Required closing parenthesis. We use this for the `group` term: it's the last
 // term in the `step` parser that starts with a parenthesis, so if that parser
 // sees a left parenthesis, here we must see a right parenthesis.
-closingParen
+closingParenthesis
   = ")"
   / .? {
       error("Expected right parenthesis");
@@ -95,6 +99,20 @@ comment "comment"
   = multiLineComment
   / singleLineComment
 
+conditionalExpression
+  = condition:logicalOrExpression __
+    "?" __ truthy:pipelineExpression __
+    ":" __ falsy:pipelineExpression
+    {
+      return annotate([
+        ops.conditional,
+        downgradeReference(condition),
+        [ops.lambda, [], downgradeReference(truthy)],
+        [ops.lambda, [], downgradeReference(falsy)]
+      ], location());
+    }
+  / logicalOrExpression
+  
 digits
   = @[0-9]+
 
@@ -108,13 +126,20 @@ doubleQuoteString "double quote string"
 doubleQuoteStringChar
   = !('"' / newLine) @textChar
 
-// Path that follows a builtin reference in a URL: `//example.com/index.html`
-doubleSlashPath
-  = "//" host:host path:path? {
-      return annotate([host, ...(path ?? [])], location());
+ellipsis = "..." / "…" // Unicode ellipsis
+
+equalityExpression
+  = head:unaryExpression tail:(__ @equalityOperator __ @unaryExpression)* {
+      return tail.length === 0
+        ? head
+        : annotate(makeBinaryOperatorChain(head, tail), location());
     }
 
-ellipsis = "..." / "…" // Unicode ellipsis
+equalityOperator
+  = "==="
+  / "!=="
+  / "=="
+  / "!="
 
 escapedChar "backslash-escaped character"
   = "\\0" { return "\0"; }
@@ -128,48 +153,18 @@ escapedChar "backslash-escaped character"
 
 // A top-level expression, possibly with leading/trailing whitespace
 expression
-  = __ @pipeline __
+  = __ @pipelineExpression __
 
-float "floating-point number"
+floatLiteral "floating-point number"
   = sign? digits? "." digits {
       return annotate([ops.literal, parseFloat(text())], location());
     }
 
-// Parse a function and its arguments, e.g. `fn(arg)`, possibly part of a chain
-// of function calls, like `fn(arg1)(arg2)(arg3)`.
-functionComposition "function composition"
-  // Function with at least one argument and maybe implicit parens arguments
-  = target:callTarget chain:args+ end:implicitParensArgs? {
-      if (end) {
-        chain.push(end);
-      }
-      return annotate(makeFunctionCall(target, chain, location()), location());
-    }
-  // Function with implicit parens arguments after maybe other arguments
-  / target:callTarget chain:args* end:implicitParensArgs {
-      if (end) {
-        chain.push(end);
-      }
-      return annotate(makeFunctionCall(target, chain, location()), location());
-    }
-
-// A reference to a function in scope: `fn` or `fn.js`.
-functionReference
-  = ref:scopeReference {
-    // If the reference looks like a builtin name, we treat it as a builtin
-    // reference, otherwise it's a regular scope reference. We can't make this
-    // distinction in the grammar.
-    const name = ref[1];
-      const builtinRegex = /^[A-Za-z][A-Za-z0-9]*$/;
-      const op = builtinRegex.test(name) ? ops.builtin : ops.scope;
-      return annotate([op, name], location());
-    }
-
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
-  = "(" __ pipeline:pipeline __ closingParen {
-    return annotate(pipeline, location());
-  }
+  = "(" expression:expression closingParenthesis {
+      return annotate(downgradeReference(expression), location());
+    }
 
 guillemetString "guillemet string"
   = '«' chars:guillemetStringChar* '»' {
@@ -179,18 +174,19 @@ guillemetString "guillemet string"
 guillemetStringChar
   = !('»' / newLine) @textChar
 
-homeTree
+// The user's home directory: `~`
+homeDirectory
   = "~" {
-      return annotate([ops.homeTree], location());
+      return annotate([ops.homeDirectory], location());
     }
 
 // A host identifier that may include a colon and port number: `example.com:80`.
 // This is used as a special case at the head of a path, where we want to
 // interpret a colon as part of a text identifier.
 host "HTTP/HTTPS host"
-  = identifier:identifier port:(":" @number)? slash:"/"? {
+  = identifier:identifier port:(":" @integerLiteral)? slashFollows:slashFollows? {
     const portText = port ? `:${port[1]}` : "";
-    const slashText = slash ? "/" : "";
+    const slashText = slashFollows ? "/" : "";
     const hostText = identifier + portText + slashText;
     return annotate([ops.literal, hostText], location());
   }
@@ -199,7 +195,7 @@ identifier "identifier"
   = chars:identifierChar+ { return chars.join(""); }
 
 identifierChar
-  = [^(){}\[\]<>\-=,/:\`"'«»\\ →⇒\t\n\r] // No unescaped whitespace or special chars
+  = [^(){}\[\]<>\?!&\|\-=,/:\`"'«»\\ →⇒\t\n\r] // No unescaped whitespace or special chars
   / @'-' !'>' // Accept a hyphen but not in a single arrow combination
   / escapedChar
 
@@ -208,33 +204,54 @@ identifierList
       return annotate(list, location());
     }
 
-implicitParensArgs "arguments with implicit parentheses"
-  = inlineSpace+ @list
+implicitParenthesesCallExpression "function call with implicit parentheses"
+  = head:arrowFunction args:(inlineSpace+ @implicitParensthesesArguments)? {
+      return args ? makeCall(head, args) : head;
+    }
+    
+// A separated list of values for an implicit parens call. This differs from
+// `list` in that the value term can't be a pipeline.
+implicitParensthesesArguments
+  = values:shorthandFunction|1.., separator| separator? {
+      return annotate(values, location());
+    }
 
 inlineSpace
   = [ \t]
 
-integer "integer"
+integerLiteral "integer"
   = sign? digits {
       return annotate([ops.literal, parseInt(text())], location());
     }
-
-// A lambda expression: `=foo()`
-lambda "lambda function"
-  = "=" __ pipeline:pipeline {
-      return annotate([ops.lambda, ["_"], pipeline], location());
+    
+// A separated list of values
+list "list"
+  = values:pipelineExpression|1.., separator| separator? {
+      return annotate(values, location());
     }
 
-// A path that begins with a slash: `/foo/bar`
-leadingSlashPath "path with a leading slash"
-  = "/" path:path? {
-      return annotate(path ?? [], location());
+literal
+  = numericLiteral
+  / stringLiteral
+
+logicalAndExpression
+  = head:equalityExpression tail:(__ "&&" __ @equalityExpression)* {
+      return tail.length === 0
+        ? head
+        : annotate(
+          [ops.logicalAnd, downgradeReference(head), ...makeDeferredArguments(tail)],
+          location()
+        );
     }
 
-// A separated list of values
-list "list"
-  = values:value|1.., separator| separator? {
-      return annotate(values, location());
+logicalOrExpression
+  = head:nullishCoalescingExpression tail:(__ "||" __ @nullishCoalescingExpression)* {
+      return tail.length === 0
+        ? head
+        : annotate(
+          [ops.logicalOr, downgradeReference(head), ...makeDeferredArguments(tail)],
+          location()
+        );
     }
 
 multiLineComment
@@ -247,27 +264,28 @@ namespace
     return annotate([ops.builtin, (at ?? "") + chars.join("") + ":"], location());
   }
 
-// A namespace followed by a path: `fn:a/b/c`
-namespacePath
-  = fn:namespace path:doubleSlashPath {
-      return annotate(makeFunctionCall(fn, [path], location()), location());
-    }
-  / fn:namespace path:path {
-      return annotate(makeFunctionCall(fn, [path], location()), location());
-    }
-
 newLine
   = "\n"
   / "\r\n"
   / "\r"
 
 // A number
-number "number"
-  = float
-  / integer
+numericLiteral "number"
+  = floatLiteral
+  / integerLiteral
+
+nullishCoalescingExpression
+  = head:logicalAndExpression tail:(__ "??" __ @logicalAndExpression)* {
+      return tail.length === 0
+        ? head
+        : annotate(
+          [ops.nullishCoalescing, downgradeReference(head), ...makeDeferredArguments(tail)],
+          location()
+        );
+    }
 
 // An object literal: `{foo: 1, bar: 2}`
-object "object literal"
+objectLiteral "object literal"
   = "{" __ entries:objectEntries? __ closingBrace {
       return annotate(makeObject(entries ?? [], ops.object), location());
     }
@@ -286,7 +304,7 @@ objectEntry
 
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
-  = key:objectKey __ "=" __ pipeline:pipeline {
+  = key:objectKey __ "=" __ pipeline:pipelineExpression {
       return annotate(
         makeProperty(key, annotate([ops.getter, pipeline], location())),
         location()
@@ -302,7 +320,7 @@ objectKey "object key"
 
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
-  = key:objectKey __ ":" __ pipeline:pipeline {
+  = key:objectKey __ ":" __ pipeline:pipelineExpression {
       return annotate(makeProperty(key, pipeline), location());
     }
 
@@ -316,96 +334,129 @@ objectPublicKey
   = identifier:identifier slash:"/"? {
     return identifier + (slash ?? "");
   }
-  / string:string {
+  / string:stringLiteral {
     // Remove `ops.literal` from the string code
     return string[1];
   }
 
-parameterizedLambda
-  = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ pipeline:pipeline {
-      return annotate([ops.lambda, parameters ?? [], pipeline], location());
-    }
-
 // Function arguments in parentheses
-parensArgs "function arguments in parentheses"
+parenthesesArguments "function arguments in parentheses"
   = "(" __ list:list? __ ")" {
       return annotate(list ?? [undefined], location());
     }
 
-// A slash-separated path of keys
+// A slash-separated path of keys: `a/b/c`
 path "slash-separated path"
   // Path with at least a tail
-  = head:pathElement|0..| tail:pathTail {
-      let path = tail ? [...head, tail] : head;
-      // Remove parts for consecutive slashes
-      path = path.filter((part) => part[1] !== "/");
-      return annotate(path, location());
-    }
-  // Path with slashes, maybe no tail
-  / head:pathElement|1..| tail:pathTail? {
-      let path = tail ? [...head, tail] : head;
-      // Remove parts for consecutive slashes
-      path = path.filter((part) => part[1] !== "/");
-      return annotate(path, location());
-  }
+  = segments:pathSegment|1..| {
+      // Drop empty segments that represent consecutive or final slashes
+      segments = segments.filter(segment => segment);
+      return annotate(segments, location());
+    }
+
+// A slash-separated path of keys that follows a call target
+pathArguments
+  = path:path {
+      return annotate([ops.traverse, ...path], location());
+    }
 
-// A path key followed by a slash
-pathElement
-  = chars:pathKeyChar* "/" {
-    return annotate([ops.literal, chars.join("") + "/"], location());
+// A single key in a slash-separated path: `/a`
+pathKey
+  = chars:pathSegmentChar+ slashFollows:slashFollows? {
+    // Append a trailing slash if one follows (but don't consume it)
+    const key = chars.join("") + (slashFollows ? "/" : "");
+    return annotate([ops.literal, key], location());
   }
 
-// A single character in a slash-separated path.
-pathKeyChar
+pathSegment
+  = "/" @pathKey?
+
+// A single character in a slash-separated path segment
+pathSegmentChar
   // This is more permissive than an identifier. It allows some characters like
   // brackets or quotes that are not allowed in identifiers.
   = [^(){}\[\],:/\\ \t\n\r]
   / escapedChar
 
-// A path key without a slash
-pathTail
-  = chars:pathKeyChar+ {
-    return annotate([ops.literal, chars.join("")], location());
-  }
-
 // A pipeline that starts with a value and optionally applies a series of
 // functions to it.
-pipeline
-  = head:value tail:(__ singleArrow __ @pipelineStep)* {
-      return tail.length === 0
-        ? head
-        : annotate(makePipeline([head, ...tail]), location());
+pipelineExpression
+  = head:shorthandFunction tail:(__ singleArrow __ @shorthandFunction)* {
+      return tail.reduce(makePipeline, downgradeReference(head));
     }
 
-// A step in a pipeline
-pipelineStep
-  = lambda
-  / parameterizedLambda
-  / callTarget
+primary
+  = literal
+  / arrayLiteral
+  / objectLiteral
+  / group
+  / templateLiteral
+  / reference
 
 // Top-level Origami progam with possible shebang directive (which is ignored)
 program "Origami program"
   = shebang? @expression
 
-scopeReference "scope reference"
-  = key:identifier {
-      return annotate([ops.scope, key], location());
+// Protocol with double-slash path: `https://example.com/index.html`
+protocolExpression
+  = fn:namespace "//" host:host path:path? {
+      const keys = annotate([host, ...(path ?? [])], location());
+      return annotate(makeCall(fn, keys), location());
     }
+  / primary
 
-scopeTraverse
-  = ref:scopeReference "/" path:path? {
-      const head = [ops.scope, `${ ref[1] }/`];
-      head.location = ref.location;
-      return annotate([ops.traverse, head, ...(path ?? [])], location());
+// A namespace followed by a key: `foo:x`
+qualifiedReference
+  = fn:namespace reference:scopeReference {
+      const literal = annotate([ops.literal, reference[1]], reference.location);
+      return annotate(makeCall(fn, [literal]), location());
+    }
+
+reference
+  = rootDirectory
+  / homeDirectory
+  / qualifiedReference
+  / namespace
+  / scopeReference
+
+// A top-level folder below the root: `/foo`
+// or the root folder itself: `/`
+rootDirectory
+  = "/" key:pathKey {
+      return annotate([ops.rootDirectory, key], location());
+    }
+  / "/" !"/" {
+      return annotate([ops.rootDirectory], location());
+    }
+
+scopeReference "scope reference"
+  = identifier:identifier slashFollows:slashFollows? {
+      const id = identifier + (slashFollows ? "/" : "");
+      return annotate(makeReference(id), location());
     }
 
 separator
   = __ "," __
   / whitespaceWithNewLine
 
+// Check whether next character is a slash without consuming input
+slashFollows
+  // This expression returned `undefined` if successful; we convert to `true`
+  = &"/" {
+      return true;
+    }
+
 shebang
   = "#!" [^\n\r]* { return null; }
 
+// A shorthand lambda expression: `=foo(_)`
+shorthandFunction "lambda function"
+  // Avoid a following equal sign (for an equality)
+  = "=" !"=" __ definition:implicitParenthesesCallExpression {
+      return annotate([ops.lambda, ["_"], definition], location());
+    }
+  / implicitParenthesesCallExpression
+
 sign
   = [+\-]
 
@@ -425,23 +476,15 @@ singleQuoteStringChar
   = !("'" / newLine) @textChar
 
 spread
-  = ellipsis value:value {
+  = ellipsis __ value:conditionalExpression {
       return annotate([ops.spread, value], location());
     }
 
-start
-  = number
-
-string "string"
+stringLiteral "string"
   = doubleQuoteString
   / singleQuoteString
   / guillemetString
 
-taggedTemplate
-  = tag:callTarget "`" contents:templateLiteralContents "`" {
-      return annotate(makeTemplate(tag, contents[0], contents[1]), location());
-    }
-
 // A top-level document defining a template. This is the same as a template
 // literal, but can contain backticks at the top level.
 templateDocument "template"
@@ -485,37 +528,23 @@ templateLiteralText
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" @expression "}"
+  = "${" expression:expression "}" {
+      return annotate(expression, location());
+    }
 
 textChar
   = escapedChar
   / .
 
-// An Origami expression that produces a value, no leading/trailing whitespace
-value
-  // Literals that can't start a function call
-  = number
-  // Try functions next; they can start with expression types that follow
-  // (array, object, etc.), and we want to parse the larger thing first.
-  / parameterizedLambda
-  / functionComposition
-  / taggedTemplate
-  / namespacePath
-  // Then try parsers that look for a distinctive token at the start: an opening
-  // slash, bracket, curly brace, etc.
-  / absoluteFilePath
-  / array
-  / object
-  / lambda
-  / templateLiteral
-  / string
-  / group
-  / homeTree
-  // Things that have a distinctive character, but not at the start
-  / scopeTraverse
-  / namespace
-  // Least distinctive option is a simple scope reference, so it comes last.
-  / scopeReference
+// A unary prefix operator: `!x`
+unaryExpression
+  = operator:unaryOperator __ expression:unaryExpression {
+      return annotate(makeUnaryOperatorCall(operator, expression), location());
+    }
+  / callExpression
+
+unaryOperator
+  = "!"
 
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __