@creationix/rex 0.1.3 → 0.3.0

package/rex.js

@@ -33,38 +33,8 @@ var OPCODE_IDS = {
   mod: 20,
   neg: 21
 };
-var registeredDomainRefs = {};
-function registerDomainExtensionRef(name, refId = 0) {
-  if (!name)
-    throw new Error("Domain extension name cannot be empty");
-  if (!Number.isInteger(refId) || refId < 0)
-    throw new Error(`Invalid domain extension ref id for '${name}': ${refId}`);
-  registeredDomainRefs[name] = refId;
-}
-function registerDomainExtensionRefs(refs) {
-  for (const [name, refId] of Object.entries(refs)) {
-    registerDomainExtensionRef(name, refId);
-  }
-}
-function clearDomainExtensionRefs() {
-  for (const name of Object.keys(registeredDomainRefs))
-    delete registeredDomainRefs[name];
-}
-function getRegisteredDomainExtensionRefs() {
-  return { ...registeredDomainRefs };
-}
-function resolveDomainRefMap(overrides) {
-  if (!overrides || Object.keys(overrides).length === 0) {
-    return Object.keys(registeredDomainRefs).length > 0 ? { ...registeredDomainRefs } : undefined;
-  }
-  const merged = { ...registeredDomainRefs };
-  for (const [name, refId] of Object.entries(overrides)) {
-    if (!Number.isInteger(refId) || refId < 0)
-      throw new Error(`Invalid domain extension ref id for '${name}': ${refId}`);
-    merged[name] = refId;
-  }
-  return merged;
-}
+var FIRST_NON_RESERVED_REF = 5;
+var DOMAIN_DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
 var BINARY_TO_OPCODE = {
   add: "add",
   sub: "sub",
@@ -217,13 +187,13 @@ function needsOptionalPrefix(encoded) {
   const first = encoded[0];
   if (!first)
     return false;
-  return first === "[" || first === "{" || first === "(" || first === "=" || first === "~" || first === "?" || first === "!" || first === "|" || first === "&" || first === ">" || first === "<";
+  return first === "[" || first === "{" || first === "(" || first === "=" || first === "~" || first === "?" || first === "!" || first === "|" || first === "&" || first === ">" || first === "<" || first === "#";
 }
 function addOptionalPrefix(encoded) {
   if (!needsOptionalPrefix(encoded))
     return encoded;
   let payload = encoded;
-  if (encoded.startsWith("?(") || encoded.startsWith("!(") || encoded.startsWith("|(") || encoded.startsWith("&(") || encoded.startsWith(">(") || encoded.startsWith("<(")) {
+  if (encoded.startsWith("?(") || encoded.startsWith("!(") || encoded.startsWith("|(") || encoded.startsWith("&(") || encoded.startsWith(">(") || encoded.startsWith("<(") || encoded.startsWith("#(")) {
     payload = encoded.slice(2, -1);
   } else if (encoded.startsWith(">[") || encoded.startsWith(">{")) {
     payload = encoded.slice(2, -1);
@@ -254,6 +224,33 @@ function encodeConditionalElse(elseBranch) {
   return encodeNode(nested);
 }
 function encodeNavigation(node) {
+  const domainRefs = activeEncodeOptions?.domainRefs;
+  if (domainRefs && node.target.type === "identifier") {
+    const staticPath = [node.target.name];
+    for (const segment of node.segments) {
+      if (segment.type !== "static")
+        break;
+      staticPath.push(segment.key);
+    }
+    for (let pathLength = staticPath.length;pathLength >= 1; pathLength -= 1) {
+      const dottedName = staticPath.slice(0, pathLength).join(".");
+      const domainRef = domainRefs[dottedName];
+      if (domainRef === undefined)
+        continue;
+      const consumedStaticSegments = pathLength - 1;
+      if (consumedStaticSegments === node.segments.length) {
+        return `${encodeUint(domainRef)}'`;
+      }
+      const parts2 = [`${encodeUint(domainRef)}'`];
+      for (const segment of node.segments.slice(consumedStaticSegments)) {
+        if (segment.type === "static")
+          parts2.push(encodeBareOrLengthString(segment.key));
+        else
+          parts2.push(encodeNode(segment.key));
+      }
+      return encodeCallParts(parts2);
+    }
+  }
   const parts = [encodeNode(node.target)];
   for (const segment of node.segments) {
     if (segment.type === "static")
@@ -263,6 +260,11 @@ function encodeNavigation(node) {
   }
   return encodeCallParts(parts);
 }
+function encodeWhile(node) {
+  const cond = encodeNode(node.condition);
+  const body = addOptionalPrefix(encodeBlockExpression(node.body));
+  return `#(${cond}${body})`;
+}
 function encodeFor(node) {
   const body = addOptionalPrefix(encodeBlockExpression(node.body));
   if (node.binding.type === "binding:expr") {
@@ -399,6 +401,8 @@ function encodeNode(node) {
     }
     case "for":
       return encodeFor(node);
+    case "while":
+      return encodeWhile(node);
     case "break":
       return ";";
     case "continue":
@@ -550,6 +554,86 @@ ${indent}}`;
 function parse(source) {
   return parseDataNode(parseToIR(source));
 }
+function domainRefsFromConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("Domain config must be an object");
+  }
+  const refs = {};
+  for (const section of Object.values(config)) {
+    if (!section || typeof section !== "object" || Array.isArray(section))
+      continue;
+    mapConfigEntries(section, refs);
+  }
+  return refs;
+}
+function decodeDomainRefKey(refText) {
+  if (!refText)
+    throw new Error("Domain ref key cannot be empty");
+  if (!/^[0-9A-Za-z_-]+$/.test(refText)) {
+    throw new Error(`Invalid domain ref key '${refText}' (must use base64 alphabet 0-9a-zA-Z-_)`);
+  }
+  if (refText.length > 1 && refText[0] === "0") {
+    throw new Error(`Invalid domain ref key '${refText}' (leading zeroes are not allowed)`);
+  }
+  if (/^[1-9]$/.test(refText)) {
+    throw new Error(`Invalid domain ref key '${refText}' (reserved by core language)`);
+  }
+  let value = 0;
+  for (const char of refText) {
+    const digit = DOMAIN_DIGIT_INDEX.get(char);
+    if (digit === undefined)
+      throw new Error(`Invalid domain ref key '${refText}'`);
+    value = value * 64 + digit;
+    if (value > Number.MAX_SAFE_INTEGER) {
+      throw new Error(`Invalid domain ref key '${refText}' (must fit in 53 bits)`);
+    }
+  }
+  if (value < FIRST_NON_RESERVED_REF) {
+    throw new Error(`Invalid domain ref key '${refText}' (maps to reserved id ${value})`);
+  }
+  return value;
+}
+function mapConfigEntries(entries, refs) {
+  const sourceKindByRoot = new Map;
+  for (const root of Object.keys(refs)) {
+    sourceKindByRoot.set(root, "explicit");
+  }
+  for (const [refText, rawEntry] of Object.entries(entries)) {
+    const entry = rawEntry;
+    if (!entry || typeof entry !== "object")
+      continue;
+    if (!Array.isArray(entry.names))
+      continue;
+    const refId = decodeDomainRefKey(refText);
+    for (const rawName of entry.names) {
+      if (typeof rawName !== "string")
+        continue;
+      const existingNameRef = refs[rawName];
+      if (existingNameRef !== undefined && existingNameRef !== refId) {
+        throw new Error(`Conflicting refs for '${rawName}': ${existingNameRef} vs ${refId}`);
+      }
+      refs[rawName] = refId;
+      const root = rawName.split(".")[0];
+      if (!root)
+        continue;
+      const currentKind = rawName.includes(".") ? "implicit" : "explicit";
+      const existing = refs[root];
+      if (existing !== undefined) {
+        if (existing === refId)
+          continue;
+        const existingKind = sourceKindByRoot.get(root) ?? "explicit";
+        if (currentKind === "explicit") {
+          throw new Error(`Conflicting refs for '${root}': ${existing} vs ${refId}`);
+        }
+        if (existingKind === "explicit")
+          continue;
+        continue;
+      }
+      refs[root] = refId;
+      sourceKindByRoot.set(root, currentKind);
+    }
+  }
+}
 function stringify(value, options) {
   const indent = options?.indent ?? 2;
   const maxWidth = options?.maxWidth ?? 80;
@@ -1440,12 +1524,12 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
       if (conditionValue !== undefined || condition.type === "undefined") {
         const passes = node.head === "when" ? isDefinedValue(conditionValue) : !isDefinedValue(conditionValue);
         if (passes) {
-          const thenBlock = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
-          if (thenBlock.length === 0)
+          const thenBlock2 = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
+          if (thenBlock2.length === 0)
             return { type: "undefined" };
-          if (thenBlock.length === 1)
-            return thenBlock[0];
-          return { type: "program", body: thenBlock };
+          if (thenBlock2.length === 1)
+            return thenBlock2[0];
+          return { type: "program", body: thenBlock2 };
         }
         if (!node.elseBranch)
           return { type: "undefined" };
@@ -1467,12 +1551,26 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
           elseBranch: loweredElse.elseBranch
         };
       }
+      const thenBlock = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
+      const elseBranch = optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth);
+      let finalCondition = condition;
+      if (condition.type === "assign" && condition.op === "=" && condition.place.type === "identifier") {
+        const name = condition.place.name;
+        const reads = new Set;
+        for (const part of thenBlock)
+          collectReads(part, reads);
+        if (elseBranch)
+          collectReadsElse(elseBranch, reads);
+        if (!reads.has(name)) {
+          finalCondition = condition.value;
+        }
+      }
       return {
         type: "conditional",
         head: node.head,
-        condition,
-        thenBlock: optimizeBlock(node.thenBlock, thenEnv, currentDepth),
-        elseBranch: optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth)
+        condition: finalCondition,
+        thenBlock,
+        elseBranch
       };
     }
     case "for": {
@@ -1927,8 +2025,9 @@ function compile(source, options) {
   let lowered = options?.optimize ? optimizeIR(ir) : ir;
   if (options?.minifyNames)
     lowered = minifyLocalNamesIR(lowered);
+  const domainRefs = options?.domainConfig ? domainRefsFromConfig(options.domainConfig) : undefined;
   return encodeIR(lowered, {
-    domainRefs: resolveDomainRefMap(options?.domainRefs),
+    domainRefs,
     dedupeValues: options?.dedupeValues,
     dedupeMinBytes: options?.dedupeMinBytes
   });
@@ -2158,6 +2257,13 @@ semantics.addOperation("toIR", {
       return body[0];
     return { type: "program", body };
   },
+  WhileExpr(_while, condition, _do, block, _end) {
+    return {
+      type: "while",
+      condition: condition.toIR(),
+      body: block.toIR()
+    };
+  },
   ForExpr(_for, binding, _do, block, _end) {
     return {
       type: "for",
@@ -2304,16 +2410,13 @@ var rex_default = semantics;
 export {
   stringify,
   semantics,
-  registerDomainExtensionRefs,
-  registerDomainExtensionRef,
   parseToIR,
   parse,
   optimizeIR,
   minifyLocalNamesIR,
   grammar,
-  getRegisteredDomainExtensionRefs,
   encodeIR,
+  domainRefsFromConfig,
   rex_default as default,
-  compile,
-  clearDomainExtensionRefs
+  compile
 };

package/rex.ohm

@@ -56,6 +56,7 @@ Rex {
     = ConditionalExpr
     | DoExpr
     | ForExpr
+    | WhileExpr
     | BreakKw                        -- break
     | ContinueKw                     -- continue
     | Array
@@ -104,6 +105,9 @@ Rex {
   ForExpr
     = ForKw BindingExpr DoKw Block EndKw
 
+  WhileExpr
+    = WhileKw Expr DoKw Block EndKw
+
   DoExpr
     = DoKw Block EndKw
 
@@ -185,6 +189,7 @@ Rex {
     | whenTok
     | unlessTok
     | forTok
+    | whileTok
     | inTok
     | ofTok
     | doTok
@@ -222,6 +227,9 @@ Rex {
   UnlessKw
     = unlessTok
 
+  WhileKw
+    = whileTok
+
   ForKw
     = forTok
 
@@ -285,6 +293,9 @@ Rex {
   unlessTok
     = "unless" ~nameTail
 
+  whileTok
+    = "while" ~nameTail
+
   forTok
     = "for" ~nameTail