@weborigami/language 0.3.3-jse.3 → 0.3.3

package/src/compiler/origami.pegjs

@@ -20,15 +20,14 @@ import {
   makeBinaryOperation,
   makeCall,
   makeDeferredArguments,
-  makeDocument,
   makeJsPropertyAccess,
   makeObject,
   makePipeline,
   makeProperty,
+  makeReference,
   makeTemplate,
   makeUnaryOperation,
-  makeYamlObject,
-  markers,
+  makeYamlObject
 } from "./parserHelpers.js";
 import isOrigamiFrontMatter from "./isOrigamiFrontMatter.js";
 
@@ -41,7 +40,7 @@ __
   }
 
 additiveExpression
-  = head:multiplicativeExpression tail:(whitespaceShell @additiveOperator whitespaceShell @multiplicativeExpression)* {
+  = head:multiplicativeExpression tail:(whitespace @additiveOperator whitespace @multiplicativeExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -49,50 +48,11 @@ additiveOperator
   = "+"
   / "-"
 
-angleBracketLiteral
-  = "<" __ protocol:angleBracketProtocol "//"? path:angleBracketPath __ ">" {
-    return annotate([protocol, ...path], location());
-    }
-  / "<" __ "/" path:angleBracketPath __ ">" {
-      const root = annotate([ops.rootDirectory], location());
-      return path.length > 0 ? annotate([root, ...path], location()) : root;
-    }
-  / "<" __ "~" "/"? path:angleBracketPath __ ">" {
-      const home = annotate([ops.homeDirectory], location());
-      return path.length > 0 ? annotate([home, ...path], location()) : home;
-    }
-  / "<" __ path:angleBracketPath __ ">" {
-      // Angle bracket paths always reference scope
-      const scope = annotate([ops.scope], location());
-      return annotate([scope, ...path], location());
-    }
-
-angleBracketPath
-  = @angleBracketPathKey|0.., "/"| "/"?
-
-angleBracketPathKey
-  = chars:angleBracketPathChar+ 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 segment
-angleBracketPathChar
-  = [^/:<>] // Much more permissive than an identifier
-  / escapedChar
-
-angleBracketProtocol
-  = protocol:jsIdentifier ":" {
-      return annotate([markers.global, `${protocol[1]}:`], location());
-    }
-
 arguments "function arguments"
   = parenthesesArguments
-  / shellMode @pathArguments
+  / pathArguments
   / jsPropertyAccess
   / computedPropertyAccess
-  / optionalChaining
   / templateLiteral
 
 arrayLiteral "array"
@@ -152,7 +112,7 @@ bitwiseXorOperator
 // `fn(arg1)(arg2)(arg3)`.
 callExpression "function call"
   = head:protocolExpression tail:arguments* {
-      return tail.reduce((target, args) => makeCall(target, args, options.mode), head);
+      return tail.reduce(makeCall, head);
     }
 
 // A comma-separated list of expressions: `x, y, z`
@@ -171,7 +131,7 @@ comment "comment"
 
 computedPropertyAccess
   = __ "[" expression:expression expectClosingBracket {
-      return annotate([markers.traverse, expression], location());
+      return annotate([ops.traverse, expression], location());
     }
 
 conditionalExpression
@@ -364,16 +324,23 @@ identifierChar
 
 implicitParenthesesCallExpression "function call with implicit parentheses"
   = head:arrowFunction args:(inlineSpace+ @implicitParensthesesArguments)? {
-      return args ? makeCall(head, args, options.mode) : head;
+      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
-  = shellMode values:shorthandFunction|1.., separator| separator? {
+  = values:shorthandFunction|1.., separator| separator? {
       return annotate(values, location());
     }
 
+inherited
+  = rootDirectory
+  / homeDirectory
+  / qualifiedReference
+  / namespace
+  / scopeReference
+
 inlineSpace
   = [ \t]
 
@@ -382,13 +349,8 @@ integerLiteral "integer"
       return annotate([ops.literal, parseInt(text())], location());
     }
 
-jseMode
-  = &{ return options.mode === "jse" }
-
 jsIdentifier
-  = id:$( jsIdentifierStart jsIdentifierPart* ) {
-    return annotate([ops.literal, id], location());
-  }
+  = $( jsIdentifierStart jsIdentifierPart* )
 
 // Continuation of a JavaScript identifier
 // https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierPart
@@ -402,20 +364,20 @@ jsIdentifierStart "JavaScript identifier start"
 
 jsPropertyAccess
   = __ "." __ property:jsIdentifier {
-    return annotate([markers.traverse, property], location());
+    const literal = annotate([ops.literal, property], location());
+    return annotate([ops.traverse, literal], location());
   }
 
-jsReference "identifier reference"
-  = id:jsIdentifier {
-      return annotate([markers.reference, id], location());
-    }
-
 // A separated list of values
 list "list"
   = values:pipelineExpression|1.., separator| separator? {
       return annotate(values, location());
     }
 
+literal
+  = numericLiteral
+  / stringLiteral
+
 logicalAndExpression
   = head:bitwiseOrExpression tail:(__ "&&" __ @bitwiseOrExpression)* {
       return tail.length === 0
@@ -440,7 +402,7 @@ multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
 multiplicativeExpression
-  = head:exponentiationExpression tail:(whitespaceShell @multiplicativeOperator whitespaceShell @exponentiationExpression)* {
+  = head:exponentiationExpression tail:(whitespace @multiplicativeOperator whitespace @exponentiationExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -452,20 +414,9 @@ multiplicativeOperator
 // A namespace reference is a string of letters only, followed by a colon.
 namespace
   = chars:[A-Za-z]+ ":" {
-    return annotate([markers.global, chars.join("") + ":"], location());
+    return annotate([ops.builtin, chars.join("") + ":"], location());
   }
 
-// A new expression: `new Foo()`
-newExpression
-  = "new" __ head:jsReference tail:parenthesesArguments {
-      const args = tail?.[0] !== undefined ? tail : [];
-      return annotate([ops.construct, head, ...args], location());
-    }
-  / "new:" head:jsReference tail:parenthesesArguments {
-      const args = tail?.[0] !== undefined ? tail : [];
-      return annotate([ops.construct, head, ...args], location());
-    }
-
 newLine
   = "\n"
   / "\r\n"
@@ -529,34 +480,21 @@ objectProperty "object property"
 // A shorthand reference inside an object literal: `foo`
 objectShorthandProperty "object identifier"
   = key:objectPublicKey {
-      const reference = annotate([markers.reference, key], location());
-      return annotate([key, reference], location());
+      const inherited = annotate([ops.inherited, key], location());
+      return annotate([key, inherited], location());
     }
-  / jseMode path:angleBracketLiteral {
-    let lastKey = path.at(-1);
-    if (lastKey instanceof Array) {
-      lastKey = lastKey[1]; // get scope identifier or literal
-    }
-    return annotate([lastKey, path], location());
-  }
 
 objectPublicKey
   = identifier:identifier slash:"/"? {
-      return identifier + (slash ?? "");
-    }
+    return identifier + (slash ?? "");
+  }
   / string:stringLiteral {
-      // Remove `ops.literal` from the string code
-      return string[1];
-    }
-
-optionalChaining
-  = __ "?." __ property:jsIdentifier {
-    return annotate([ops.optionalTraverse, property], location());
+    // Remove `ops.literal` from the string code
+    return string[1];
   }
-  
+
 parameter
-  = jseMode @jsIdentifier
-  / shellMode identifier:identifier {
+  = identifier:identifier {
       return annotate([ops.literal, identifier], location());
     }
 
@@ -592,7 +530,7 @@ path "slash-separated path"
 // A slash-separated path of keys that follows a call target
 pathArguments
   = path:path {
-      return annotate([markers.traverse, ...path], location());
+      return annotate([ops.traverse, ...path], location());
     }
 
 // A single key in a slash-separated path: `/a`
@@ -618,33 +556,18 @@ pathSegmentChar
 pipelineExpression
   = head:shorthandFunction tail:(__ singleArrow __ @shorthandFunction)* {
       return annotate(
-        tail.reduce((arg, fn) => makePipeline(arg, fn, options.mode), downgradeReference(head)),
+        tail.reduce(makePipeline, downgradeReference(head)),
         location()
       );
     }
 
 primary
-  = numericLiteral
-  / stringLiteral
+  = literal
   / arrayLiteral
   / objectLiteral
   / group
   / templateLiteral
-  / shellMode @primaryShell
-  / jseMode @primaryJse
-
-// Primary allowed in JSE mode
-primaryJse
-  = angleBracketLiteral
-  / jsReference
-  / regexLiteral
-
-primaryShell
-  = rootDirectory
-  / homeDirectory
-  / qualifiedReference
-  / namespace
-  / scopeReference
+  / inherited
 
 // Top-level Origami progam with possible shebang directive (which is ignored)
 program "Origami program"
@@ -654,38 +577,19 @@ program "Origami program"
 protocolExpression
   = fn:namespace "//" host:(host / slash) path:path? {
       const keys = annotate([host, ...(path ?? [])], location());
-      return makeCall(fn, keys, options.mode);
+      return makeCall(fn, keys);
     }
-  / newExpression
   / primary
 
 // A namespace followed by a key: `foo:x`
 qualifiedReference
   = fn:namespace reference:scopeReference {
-      return makeCall(fn, [reference[1]], options.mode);
-    }
-
-regexFlags
-  = flags:[gimuy]* {
-      return flags.join("");
-    }
-
-regexLiteral
-  = "/" chars:regexLiteralChar* "/" flags:regexFlags? {
-      const regex = new RegExp(chars.join(""), flags);
-      return annotate([ops.literal, regex], location());
+      const literal = annotate([ops.literal, reference[1]], reference.location);
+      return makeCall(fn, [literal]);
     }
 
-regexLiteralChar
-  = [^/\n\r] // No unescaped slashes or newlines
-  / escapedChar
-
 relationalExpression
-  // We disallow a newline before the relational operator to support a newline
-  // as a separator in an object literal that has an object shorthand property
-  // with an angle bracket path. Otherwise the opening angle bracket would be
-  // interpreted as a relational operator.
-  = head:shiftExpression tail:(inlineSpace @relationalOperator __ @shiftExpression)* {
+  = head:shiftExpression tail:(__ @relationalOperator __ @shiftExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -695,29 +599,29 @@ relationalOperator
   / ">="
   / ">"
 
-// The root folder: `/`
+// 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 ? "/" : "");
-      const idCode = annotate([ops.literal, identifier], location());
-      return annotate([markers.reference, idCode], location());
+      return annotate(makeReference(id), location());
     }
 
 separator
   = __ "," __
-  / @whitespaceWithNewLine
+  / whitespaceWithNewLine
 
 shebang
   = "#!" [^\n\r]* { return null; }
 
-shellMode
-  = &{ return options.mode === "shell" }
-
 shiftExpression
   = head:additiveExpression tail:(__ @shiftOperator __ @additiveExpression)* {
       return tail.reduce(makeBinaryOperation, head);
@@ -731,7 +635,7 @@ shiftOperator
 // A shorthand lambda expression: `=foo(_)`
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
-  = shellMode "=" !"=" __ definition:implicitParenthesesCallExpression {
+  = "=" !"=" __ definition:implicitParenthesesCallExpression {
       const lambdaParameters = annotate(
         [annotate([ops.literal, "_"], location())],
         location()
@@ -769,20 +673,27 @@ slashFollows
     }
 
 spreadElement
-  = ellipsis __ value:expectPipelineExpression {
+  = ellipsis __ value:pipelineExpression {
       return annotate([ops.spread, value], location());
     }
 
 stringLiteral "string"
   = doubleQuoteString
   / singleQuoteString
-  / shellMode @guillemetString
+  / guillemetString
 
 // The body of a template document is a kind of template literal that can
 // contain backticks at the top level.
 templateBody "template"
   = head:templateBodyText tail:(templateSubstitution templateBodyText)* {
-      return makeTemplate(ops.templateIndent, head, tail, location());
+      const lambdaParameters = annotate(
+        [annotate([ops.literal, "_"], location())],
+        location()
+      );
+      return annotate(
+        [ops.lambda, lambdaParameters, makeTemplate(ops.templateIndent, head, tail, location())],
+        location()
+      );
     }
 
 // Template document bodies can contain backticks at the top level
@@ -796,25 +707,18 @@ templateBodyText "template text"
 
 templateDocument "template document"
   = front:frontMatterExpression __ body:templateBody {
-      const macroName = options.mode === "jse" ? "_template" : "@template";
-      return annotate(applyMacro(front, macroName, body), location());
-    }
-  / front:frontMatterYaml body:templateBody {
-      return makeDocument(options.mode, front, body, location());
+      return annotate(applyMacro(front, "@template", body), location());
     }
-  / body:templateBody {
-      const lambdaParameters = annotate(
-        [annotate([ops.literal, "_"], location())],
-        location()
-      );
-      return annotate([ops.lambda, lambdaParameters, body], location());
+  / front:frontMatterYaml? body:templateBody {
+      return front
+        ? annotate([ops.document, front, body], location())
+        : annotate(body, location());
     }
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
   = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* expectBacktick {
-      const op = options.mode === "jse" ? ops.templateStandard : ops.templateTree;
-      return makeTemplate(op, head, tail, location());
+      return makeTemplate(ops.template, head, tail, location());
     }
 
 templateLiteralChar
@@ -846,21 +750,13 @@ unaryExpression
 unaryOperator
   = "!"
   / "+"
-  // Don't match a front matter delimiter. For some reason, the negative
-  // lookahead !"--\n" doesn't work.
-  / @"-" !"-\n"
-  // Don't match a path that starts with a tilde: ~/foo
-  / @"~" !"/"
+  / "-"
+  / "~"
 
 whitespace
   = inlineSpace
   / newLine
   / comment
 
-// Whitespace required in shell mode, optional in JSE mode
-whitespaceShell
-  = shellMode whitespace
-  / jseMode __
-
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __