@weborigami/language 0.3.3 → 0.3.4-jse.5

package/src/compiler/origami.pegjs

@@ -15,19 +15,18 @@ import * as ops from "../runtime/ops.js";
 import {
   annotate,
   applyMacro,
-  downgradeReference,
   makeArray,
   makeBinaryOperation,
   makeCall,
   makeDeferredArguments,
-  makeJsPropertyAccess,
+  makeDocument,
   makeObject,
+  makePath,
   makePipeline,
-  makeProperty,
-  makeReference,
   makeTemplate,
   makeUnaryOperation,
-  makeYamlObject
+  makeYamlObject,
+  markers,
 } from "./parserHelpers.js";
 import isOrigamiFrontMatter from "./isOrigamiFrontMatter.js";
 
@@ -46,13 +45,45 @@ additiveExpression
 
 additiveOperator
   = "+"
-  / "-"
+  / minus
+
+angleBracketLiteral
+  = "<" scheme:uriScheme "//"? path:angleBracketPath ">" {
+    return annotate([scheme, ...path], location());
+    }
+  / "</" path:angleBracketPath ">" {
+      const external = annotate([markers.external, "/"], location());
+      return annotate([markers.traverse, external, ...path], location());
+    }
+  / "<" path:angleBracketPath ">" {
+      const [head, ...tail] = path;
+      const external = annotate([markers.external, head[1]], location());
+      return annotate([markers.traverse, external, ...tail], location());
+    }
+
+angleBracketPath
+  = @angleBracketKey|0.., "/"| "/"?
+
+// Single key in an angle bracket path, possibly with a trailing slash
+angleBracketKey
+  = 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 an angle bracket key
+angleBracketPathChar
+  // Accept anything that doesn't end the angle bracket key or path
+  = [^/>\t\n\r]
+  / escapedChar
 
 arguments "function arguments"
   = parenthesesArguments
   / pathArguments
-  / jsPropertyAccess
+  / propertyAccess
   / computedPropertyAccess
+  // / optionalChaining
   / templateLiteral
 
 arrayLiteral "array"
@@ -85,7 +116,7 @@ arrowFunction
   / conditionalExpression
 
 bitwiseAndExpression
-  = head:equalityExpression tail:(__ @bitwiseAndOperator __ @equalityExpression)* {
+  = head:equalityExpression tail:(whitespace @bitwiseAndOperator whitespace @equalityExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -93,7 +124,7 @@ bitwiseAndOperator
   = @"&" !"&"
 
 bitwiseOrExpression
-  = head:bitwiseXorExpression tail:(__ @bitwiseOrOperator __ @bitwiseXorExpression)* {
+  = head:bitwiseXorExpression tail:(whitespace @bitwiseOrOperator whitespace @bitwiseXorExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -101,7 +132,7 @@ bitwiseOrOperator
   = @"|" !"|"
 
 bitwiseXorExpression
-  = head:bitwiseAndExpression tail:(__ @bitwiseXorOperator __ @bitwiseAndExpression)* {
+  = head:bitwiseAndExpression tail:(whitespace @bitwiseXorOperator whitespace @bitwiseAndExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -111,8 +142,11 @@ bitwiseXorOperator
 // 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.reduce(makeCall, head);
+  = head:uriExpression tail:arguments* {
+      return tail.reduce(
+        (target, args) => makeCall(target, args, location()),
+        head
+      );
     }
 
 // A comma-separated list of expressions: `x, y, z`
@@ -131,7 +165,7 @@ comment "comment"
 
 computedPropertyAccess
   = __ "[" expression:expression expectClosingBracket {
-      return annotate([ops.traverse, expression], location());
+      return annotate([markers.property, expression], location());
     }
 
 conditionalExpression
@@ -145,9 +179,9 @@ conditionalExpression
       const deferred = makeDeferredArguments(tail);
       return annotate([
         ops.conditional,
-        downgradeReference(condition),
-        downgradeReference(deferred[0]),
-        downgradeReference(deferred[1])
+        condition,
+        deferred[0],
+        deferred[1]
       ], location());
     }
   
@@ -249,7 +283,7 @@ expectPipelineExpression
     }
 
 exponentiationExpression
-  = left:unaryExpression right:(__ "**" __ @exponentiationExpression)? {
+  = left:unaryExpression right:(whitespace "**" whitespace @exponentiationExpression)? {
       return right ? annotate([ops.exponentiation, left, right], location()) : left;
     }
 
@@ -286,7 +320,7 @@ frontMatterYaml "YAML front matter"
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
   = "(" expression:expression expectClosingParenthesis {
-    return annotate(downgradeReference(expression), location());
+    return annotate(expression, location());
   }
 
 guillemetString "guillemet string"
@@ -297,50 +331,56 @@ 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:(":" @integerLiteral)? slashFollows:slashFollows? {
-    const portText = port ? `:${port[1]}` : "";
-    const slashText = slashFollows ? "/" : "";
-    const hostText = identifier + portText + slashText;
-    return annotate([ops.literal, hostText], location());
+  = name:hostname port:(":" @integerLiteral)? slashFollows:slashFollows? {
+      const portText = port ? `:${port[1]}` : "";
+      const slashText = slashFollows ? "/" : "";
+      const host = name + portText + slashText;
+      return annotate([ops.literal, host], location());
+    }
+
+hostname
+  = key {
+    return text();
   }
 
-identifier "identifier"
-  = chars:identifierChar+ { return chars.join(""); }
+// JavaScript-compatible identifier
+identifier
+  = id:$( identifierStart identifierPart* ) {
+    return id;
+  }
 
-identifierChar
-  = [^(){}\[\]<>\?!\|\-=,/:\`"'«»\\→⇒… \t\n\r] // No unescaped whitespace or special chars
-  / @'-' !'>' // Accept a hyphen but not in a single arrow combination
-  / escapedChar
+// Identifier as a literal
+identifierLiteral
+  = id:identifier {
+      return annotate([ops.literal, id], location());
+    }
+
+// Continuation of a JavaScript identifier
+// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierPart
+identifierPart "JavaScript identifier continuation"
+  = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
+
+// Start of a JavaScript identifier
+// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierStart
+identifierStart "JavaScript identifier start"
+  = char:. &{ return char.match(/[$_\p{ID_Start}]/u) }
 
 implicitParenthesesCallExpression "function call with implicit parentheses"
   = head:arrowFunction args:(inlineSpace+ @implicitParensthesesArguments)? {
-      return args ? makeCall(head, args) : head;
+      return args ? makeCall(head, args, location()) : 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? {
+  = shellMode values:shorthandFunction|1.., separator| separator? {
       return annotate(values, location());
     }
 
-inherited
-  = rootDirectory
-  / homeDirectory
-  / qualifiedReference
-  / namespace
-  / scopeReference
-
 inlineSpace
   = [ \t]
 
@@ -349,24 +389,32 @@ integerLiteral "integer"
       return annotate([ops.literal, parseInt(text())], location());
     }
 
-jsIdentifier
-  = $( jsIdentifierStart jsIdentifierPart* )
-
-// Continuation of a JavaScript identifier
-// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierPart
-jsIdentifierPart "JavaScript identifier continuation"
-  = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
+// A key in a path or an expression that looks like one
+key
+  = keyCharStart keyChar* {
+    return text();
+  }
 
-// Start of a JavaScript identifier
-// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierStart
-jsIdentifierStart "JavaScript identifier start"
-  = char:. &{ return char.match(/[$_\p{ID_Start}]/u) }
+// Character after the first in a key
+keyChar
+  = keyCharStart
+  // Also allow some math operators (not slash)
+  / "!"
+  / "+"
+  / minus
+  / "*"
+  / "%"
+  / "&"
+  / "|"
+  / "^"
 
-jsPropertyAccess
-  = __ "." __ property:jsIdentifier {
-    const literal = annotate([ops.literal, property], location());
-    return annotate([ops.traverse, literal], location());
-  }
+// First character in a key
+keyCharStart
+  // All JS identifier characters
+  = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
+  / "."
+  / "~"
+  / "@"
 
 // A separated list of values
 list "list"
@@ -374,16 +422,12 @@ list "list"
       return annotate(values, location());
     }
 
-literal
-  = numericLiteral
-  / stringLiteral
-
 logicalAndExpression
   = head:bitwiseOrExpression tail:(__ "&&" __ @bitwiseOrExpression)* {
       return tail.length === 0
         ? head
         : annotate(
-          [ops.logicalAnd, downgradeReference(head), ...makeDeferredArguments(tail)],
+          [ops.logicalAnd, head, ...makeDeferredArguments(tail)],
           location()
         );
     }
@@ -393,11 +437,17 @@ logicalOrExpression
       return tail.length === 0
         ? head
         : annotate(
-          [ops.logicalOr, downgradeReference(head), ...makeDeferredArguments(tail)],
+          [ops.logicalOr, head, ...makeDeferredArguments(tail)],
           location()
         );
     }
 
+// Unary or binary minus operator
+minus
+  // Don't match a front matter delimiter or pipeline operator. For some reason,
+  // the negative lookahead !"--\n" doesn't work.
+  = @"-" !"-\n" !">"
+
 multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
@@ -411,11 +461,16 @@ multiplicativeOperator
   / "/"
   / "%"
 
-// A namespace reference is a string of letters only, followed by a colon.
-namespace
-  = chars:[A-Za-z]+ ":" {
-    return annotate([ops.builtin, chars.join("") + ":"], location());
-  }
+// A new expression: `new Foo()`
+newExpression
+  = "new" __ head:pathLiteral tail:parenthesesArguments? {
+      const args = tail?.[0] !== undefined ? tail : [];
+      return annotate([ops.construct, head, ...args], location());
+    }
+  / "new:" head:pathLiteral tail:parenthesesArguments {
+      const args = tail?.[0] !== undefined ? tail : [];
+      return annotate([ops.construct, head, ...args], location());
+    }
 
 newLine
   = "\n"
@@ -432,7 +487,7 @@ nullishCoalescingExpression
       return tail.length === 0
         ? head
         : annotate(
-          [ops.nullishCoalescing, downgradeReference(head), ...makeDeferredArguments(tail)],
+          [ops.nullishCoalescing, head, ...makeDeferredArguments(tail)],
           location()
         );
     }
@@ -458,10 +513,8 @@ objectEntry
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
   = key:objectKey __ "=" __ pipeline:expectPipelineExpression {
-      return annotate(
-        makeProperty(key, annotate([ops.getter, pipeline], location())),
-        location()
-      );
+      const getter = annotate([ops.getter, pipeline], location());
+      return annotate([key, getter], location());
     }
 
 objectHiddenKey
@@ -474,28 +527,42 @@ objectKey "object key"
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
   = key:objectKey __ ":" __ pipeline:expectPipelineExpression {
-      return annotate(makeProperty(key, pipeline), location());
+      return annotate([key, pipeline], location());
     }
 
 // A shorthand reference inside an object literal: `foo`
 objectShorthandProperty "object identifier"
   = key:objectPublicKey {
-      const inherited = annotate([ops.inherited, key], location());
-      return annotate([key, inherited], location());
+      const reference = annotate([markers.reference, key], location());
+      const traverse = annotate([markers.traverse, reference], location());
+      return annotate([key, traverse], location());
+    }
+  / 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 ?? "");
+  = key:key slash:"/"? {
+    return text();
   }
   / string:stringLiteral {
-    // Remove `ops.literal` from the string code
-    return string[1];
+      // Remove `ops.literal` from the string code
+      return string[1];
+    }
+
+optionalChaining
+  = __ "?." __ property:identifier {
+    return annotate([ops.optionalTraverse, property], location());
   }
 
+// Name of a unction parameter
 parameter
-  = identifier:identifier {
-      return annotate([ops.literal, identifier], location());
+  = key:key {
+      return annotate([ops.literal, key], location());
     }
 
 parameterList
@@ -505,11 +572,8 @@ parameterList
 
 // A list with a single identifier
 parameterSingleton
-  = identifier:identifier {
-      return annotate(
-        [annotate([ops.literal, identifier], location())],
-        location()
-      );
+  = param:parameter {
+      return annotate([param], location());
     }
 
 // Function arguments in parentheses
@@ -518,78 +582,88 @@ parenthesesArguments "function arguments in parentheses"
       return annotate(list ?? [undefined], 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 that follows a call target
+// A slash-separated path of keys that follows a call target, such as the path
+// after the slash in `(x)/y/z`
 pathArguments
-  = path:path {
-      return annotate([ops.traverse, ...path], location());
+  = "/" keys:pathKeys? {
+      const args = keys ?? [];
+      return annotate([markers.traverse, ...args], 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());
-  }
+// Sequence of keys that may each have trailing slashes
+pathKeys
+  = pathSegment|1..|
+  
+// A path without angle brackets
+pathLiteral
+  = keys:pathKeys {
+      return makePath(keys);
+    }
 
+// A path key with an optional trailing slash
 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
+  = key:key "/"? {
+      return annotate([ops.literal, text()], location());
+    }
+  // A single slash is a path key
+  / "/" {
+      return annotate([ops.literal, text()], location());
+    }
 
 // A pipeline that starts with a value and optionally applies a series of
 // functions to it.
 pipelineExpression
   = head:shorthandFunction tail:(__ singleArrow __ @shorthandFunction)* {
       return annotate(
-        tail.reduce(makePipeline, downgradeReference(head)),
+        tail.reduce((arg, fn) => makePipeline(arg, fn, location()), head),
         location()
       );
     }
 
 primary
-  = literal
+  // The following start with distinct characters
+  = stringLiteral
   / arrayLiteral
   / objectLiteral
   / group
+  / angleBracketLiteral
+  / regexLiteral
   / templateLiteral
-  / inherited
+
+  // These are more ambiguous
+  / @numericLiteral !keyChar // numbers + chars would be a key
+  / pathLiteral
 
 // 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 / slash) path:path? {
-      const keys = annotate([host, ...(path ?? [])], location());
-      return makeCall(fn, keys);
+propertyAccess
+  = __ "." __ property:identifierLiteral {
+    return annotate([markers.property, property], location());
+  }
+
+regexFlags
+  = flags:[gimuy]* {
+      return flags.join("");
     }
-  / primary
 
-// A namespace followed by a key: `foo:x`
-qualifiedReference
-  = fn:namespace reference:scopeReference {
-      const literal = annotate([ops.literal, reference[1]], reference.location);
-      return makeCall(fn, [literal]);
+regexLiteral
+  = "/" chars:regexLiteralChar* "/" flags:regexFlags? {
+      const regex = new RegExp(chars.join(""), flags);
+      return annotate([ops.literal, regex], location());
     }
 
+regexLiteralChar
+  = [^/\n\r] // No unescaped slashes or newlines
+  / escapedChar
+
 relationalExpression
-  = head:shiftExpression tail:(__ @relationalOperator __ @shiftExpression)* {
+  // 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)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -599,29 +673,16 @@ relationalOperator
   / ">="
   / ">"
 
-// 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
+  / @whitespaceWithNewLine
 
 shebang
   = "#!" [^\n\r]* { return null; }
 
+shellMode
+  = &{ return options.mode === "shell" }
+
 shiftExpression
   = head:additiveExpression tail:(__ @shiftOperator __ @additiveExpression)* {
       return tail.reduce(makeBinaryOperation, head);
@@ -635,7 +696,7 @@ shiftOperator
 // A shorthand lambda expression: `=foo(_)`
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
-  = "=" !"=" __ definition:implicitParenthesesCallExpression {
+  = shellMode "=" !"=" __ definition:implicitParenthesesCallExpression {
       const lambdaParameters = annotate(
         [annotate([ops.literal, "_"], location())],
         location()
@@ -665,6 +726,12 @@ slash
     return annotate([ops.literal, "/"], location());
   }
 
+// One or more consecutive slashes
+slashes
+  = "/"+ {
+      return annotate([ops.literal, "/"], location());
+    }
+
 // Check whether next character is a slash without consuming input
 slashFollows
   // This expression returned `undefined` if successful; we convert to `true`
@@ -673,27 +740,20 @@ slashFollows
     }
 
 spreadElement
-  = ellipsis __ value:pipelineExpression {
+  = ellipsis __ value:expectPipelineExpression {
       return annotate([ops.spread, value], location());
     }
 
 stringLiteral "string"
   = doubleQuoteString
   / singleQuoteString
-  / guillemetString
+  / shellMode @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)* {
-      const lambdaParameters = annotate(
-        [annotate([ops.literal, "_"], location())],
-        location()
-      );
-      return annotate(
-        [ops.lambda, lambdaParameters, makeTemplate(ops.templateIndent, head, tail, location())],
-        location()
-      );
+      return makeTemplate(ops.templateIndent, head, tail, location());
     }
 
 // Template document bodies can contain backticks at the top level
@@ -707,18 +767,27 @@ templateBodyText "template text"
 
 templateDocument "template document"
   = front:frontMatterExpression __ body:templateBody {
-      return annotate(applyMacro(front, "@template", body), location());
+      const macroName = text().includes("@template") ? "@template" : "_template";
+      return annotate(applyMacro(front, macroName, body), location());
     }
-  / front:frontMatterYaml? body:templateBody {
-      return front
-        ? annotate([ops.document, front, body], location())
-        : annotate(body, location());
+  / front:frontMatterYaml body:templateBody {
+      return makeDocument(front, body, location());
+    }
+  / body:templateBody {
+      if (options.front) {
+        return makeDocument(options.front, body, location());
+      }
+      const lambdaParameters = annotate(
+        [annotate([ops.literal, "_"], location())],
+        location()
+      );
+      return annotate([ops.lambda, lambdaParameters, body], location());
     }
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
   = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* expectBacktick {
-      return makeTemplate(ops.template, head, tail, location());
+      return makeTemplate(ops.templateTree, head, tail, location());
     }
 
 templateLiteralChar
@@ -742,16 +811,64 @@ textChar
 
 // A unary prefix operator: `!x`
 unaryExpression
-  = operator:unaryOperator __ expression:unaryExpression {
+  = operator:unaryOperator __ expression:expectExpression {
       return makeUnaryOperation(operator, expression, location());
     }
   / callExpression
 
+// URI
+uri
+  // Double slashes after colon: `https://example.com/index.html`
+  = scheme:uriScheme "//" host:host path:("/" uriPath)? {
+      const rest = path ? path[1] : [];
+      const keys = annotate([host, ...rest], location());
+      return makeCall(scheme, keys, location());
+    }
+  // No slashes after colon: `files:assets`
+  / scheme:uriScheme keys:pathKeys {
+      return makeCall(scheme, keys, location());
+    }
+
+// URI expression
+uriExpression
+  = uri
+  / newExpression
+  / primary
+
+// A single key in a path, possibly with trailing slash: `a/`, `b`
+uriKey
+  = chars:uriKeyChar+ "/"? {
+      return annotate([ops.literal, text()], location());
+    }
+  / "/" {
+    // A single slash is a path key
+    return annotate([ops.literal, ""], location());
+    }
+
+// A single character in a URI key
+uriKeyChar
+  // Accept anything that doesn't end the URI key or path
+  = [^/,\)\]\}\s]
+  / escapedChar
+
+// A slash-separated path of keys: `a/b/c`
+uriPath "slash-separated path"
+  = keys:uriKey|1..| {
+      return annotate(keys, location());
+    }
+
+// URI scheme, commonly called a protocol
+// See https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
+uriScheme
+  = [a-z][a-z0-9+-.]*[:] {
+      return annotate([markers.global, text()], location());
+    }
+
 unaryOperator
   = "!"
   / "+"
-  / "-"
-  / "~"
+  / @"~" ![\/\)\]\}]  // don't match `~/` or end of term
+  / minus
 
 whitespace
   = inlineSpace