@weborigami/language 0.0.73 → 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,20 +53,22 @@ arrayEntries
 
 arrayEntry
   = spread
-  / expr
-
-// Something that can be called. This is more restrictive than the `expr`
-// parser; it doesn't accept regular function calls.
-callTarget "function call"
-  = absoluteFilePath
-  / array
-  / object
-  / lambda
-  / parameterizedLambda
-  / protocolCall
-  / group
-  / scopeTraverse
-  / scopeReference
+  / 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.
@@ -85,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");
@@ -96,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]+
 
@@ -111,6 +128,19 @@ doubleQuoteStringChar
 
 ellipsis = "..." / "…" // Unicode ellipsis
 
+equalityExpression
+  = head:unaryExpression tail:(__ @equalityOperator __ @unaryExpression)* {
+      return tail.length === 0
+        ? head
+        : annotate(makeBinaryOperatorChain(head, tail), location());
+    }
+
+equalityOperator
+  = "==="
+  / "!=="
+  / "=="
+  / "!="
+
 escapedChar "backslash-escaped character"
   = "\\0" { return "\0"; }
   / "\\b" { return "\b"; }
@@ -121,42 +151,19 @@ escapedChar "backslash-escaped character"
   / "\\v" { return "\v"; }
   / "\\" @.
 
-// An Origami expression, no leading/trailing whitespace
-expr
-  = pipeline
-
-// Top-level Origami expression, possible shebang directive and leading/trailing
-// whitepsace.
-expression "Origami expression"
-  = shebang? __ @expr __
+// A top-level expression, possibly with leading/trailing whitespace
+expression
+  = __ @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());
-    }
-
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
-  = "(" __ expr:expr __ closingParen {
-      return annotate(expr, location());
+  = "(" expression:expression closingParenthesis {
+      return annotate(downgradeReference(expression), location());
     }
 
 guillemetString "guillemet string"
@@ -167,13 +174,20 @@ guillemetString "guillemet string"
 guillemetStringChar
   = !('»' / newLine) @textChar
 
+// The user's home directory: `~`
+homeDirectory
+  = "~" {
+      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)? {
+  = identifier:identifier port:(":" @integerLiteral)? slashFollows:slashFollows? {
     const portText = port ? `:${port[1]}` : "";
-    const hostText = identifier + portText;
+    const slashText = slashFollows ? "/" : "";
+    const hostText = identifier + portText + slashText;
     return annotate([ops.literal, hostText], location());
   }
 
@@ -181,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
 
@@ -190,55 +204,88 @@ identifierList
       return annotate(list, location());
     }
 
-implicitParensArgs "arguments with implicit parentheses"
-  // Implicit parens args are a separate list of `step`, not `expr`, because
-  // they can't contain a pipeline.
-  = inlineSpace+ args:step|1.., separator| separator? {
-      /* Stuff */
-      return annotate(args, location());
+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"
-  = "=" __ expr:expr {
-      return annotate([ops.lambda, ["_"], expr], 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 expressions
-list "list"
-  = list:expr|1.., separator| separator? {
-      return annotate(list, location());
+logicalOrExpression
+  = head:nullishCoalescingExpression tail:(__ "||" __ @nullishCoalescingExpression)* {
+      return tail.length === 0
+        ? head
+        : annotate(
+          [ops.logicalOr, downgradeReference(head), ...makeDeferredArguments(tail)],
+          location()
+        );
     }
 
 multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
+// A namespace reference is a string of letters only, followed by a colon.
+// For the time being, we also allow a leading `@`, which is deprecated.
+namespace
+  = at:"@"? chars:[A-Za-z]+ ":" {
+    return annotate([ops.builtin, (at ?? "") + chars.join("") + ":"], 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());
     }
@@ -257,8 +304,11 @@ objectEntry
 
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
-  = key:objectKey __ "=" __ value:expr {
-      return annotate(makeProperty(key, [ops.getter, value]), location());
+  = key:objectKey __ "=" __ pipeline:pipelineExpression {
+      return annotate(
+        makeProperty(key, annotate([ops.getter, pipeline], location())),
+        location()
+      );
     }
 
 objectHiddenKey
@@ -270,8 +320,8 @@ objectKey "object key"
 
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
-  = key:objectKey __ ":" __ value:expr {
-      return annotate(makeProperty(key, value), location());
+  = key:objectKey __ ":" __ pipeline:pipelineExpression {
+      return annotate(makeProperty(key, pipeline), location());
     }
 
 // A shorthand reference inside an object literal: `foo`
@@ -284,99 +334,135 @@ 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 __ expr:expr {
-      return annotate([ops.lambda, parameters ?? [], expr], location());
-    }
-
 // Function arguments in parentheses
-parensArgs "function arguments in parentheses"
+parenthesesArguments "function arguments in parentheses"
   = "(" __ list:list? __ ")" {
       return annotate(list ?? [undefined], location());
     }
 
-pipeline
-  = steps:(@step|1.., __ singleArrow __ |) {
-      return annotate(makePipeline(steps), location());
+// A slash-separated path of keys: `a/b/c`
+path "slash-separated path"
+  // Path with at least a tail
+  = 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
-path "slash-separated path"
-  = 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());
+// 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.
+pipelineExpression
+  = head:shorthandFunction tail:(__ singleArrow __ @shorthandFunction)* {
+      return tail.reduce(makePipeline, downgradeReference(head));
+    }
 
-// Parse a protocol call like `fn://foo/bar`.
-// There can be zero, one, or two slashes after the colon.
-protocolCall "function call using protocol: syntax"
-  = protocol:protocol ":" "/"|0..2| host:host path:leadingSlashPath? {
-      return annotate([protocol, host, ...(path ?? [])], location());
+primary
+  = literal
+  / arrayLiteral
+  / objectLiteral
+  / group
+  / templateLiteral
+  / reference
+
+// Top-level Origami progam with possible shebang directive (which is ignored)
+program "Origami program"
+  = shebang? @expression
+
+// 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
 
-protocol "protocol"
-  = reservedProtocol
-  / scopeReference
+// 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());
+    }
 
-reservedProtocol "reserved protocol"
-  = "explore" { return ops.explorableSite; }
-  / "https" { return ops.https; } // Must come before "http"
-  / "http" { return ops.http; }
-  / "new" { return ops.constructor; }
-  / "package" { return [ops.scope, "@package"] } // Alias
-  / "treehttps" { return ops.treeHttps; } // Must come before `treehttp`
-  / "treehttp" { return ops.treeHttp; } // Must come before `tree`
-  / "tree" { return ops.treeHttps; }
+reference
+  = rootDirectory
+  / homeDirectory
+  / qualifiedReference
+  / namespace
+  / scopeReference
 
-scopeReference "scope reference"
-  = key:identifier {
-      return annotate([ops.scope, key], location());
+// 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());
     }
 
-scopeTraverse
-  = ref:scopeReference "/" path:path {
-      const head = [ops.scope, `${ ref[1] }/`];
-      head.location = ref.location;
-      return annotate([ops.traverse, head, ...path], 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
   = [+\-]
 
-singleArrow = "→" / "->"
+singleArrow
+  = "→"
+  / "->"
 
 singleLineComment
   = "//" [^\n\r]* { return null; }
@@ -390,47 +476,15 @@ singleQuoteStringChar
   = !("'" / newLine) @textChar
 
 spread
-  = ellipsis expr:expr {
-      return annotate([ops.spread, expr], location());
-    }
-
-// A single step in a pipeline, or a top-level expression
-step
-  // 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.
-  / functionComposition
-  // Then try parsers that look for a distinctive token at the start: an opening
-  // slash, bracket, curly brace, etc.
-  / absoluteFilePath
-  / array
-  / object
-  / lambda
-  / parameterizedLambda
-  / templateLiteral
-  / string
-  / group
-  // Things that have a distinctive character, but not at the start
-  / protocolCall
-  / taggedTemplate
-  / scopeTraverse
-  // Least distinctive option is a simple scope reference, so it comes last.
-  / scopeReference
-
-start
-  = number
+  = ellipsis __ value:conditionalExpression {
+      return annotate([ops.spread, value], location());
+    }
 
-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"
@@ -474,11 +528,23 @@ templateLiteralText
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" __ @expr __ "}"
+  = "${" expression:expression "}" {
+      return annotate(expression, location());
+    }
 
 textChar
   = escapedChar
   / .
 
+// A unary prefix operator: `!x`
+unaryExpression
+  = operator:unaryOperator __ expression:unaryExpression {
+      return annotate(makeUnaryOperatorCall(operator, expression), location());
+    }
+  / callExpression
+
+unaryOperator
+  = "!"
+
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __