@temperlang/core 0.3.0 → 0.4.0

package/regex.js

@@ -1,71 +1,68 @@
-export function regexCompiledFound(_, compiled, text) {
+// @ts-check
+
+export const regexCompiledFound = (_, compiled, text) => {
+  compiled.lastIndex = 0;
   return compiled.test(text);
-}
+};
 
-export function regexCompiledFind(_, compiled, text, regexRefs) {
-  const match = regexCompiledFindEx(_, compiled, text, regexRefs);
+/**
+ * @param {RegExp} compiled
+ * @param {string} text
+ * @param {number} begin
+ */
+export const regexCompiledFind = (_, compiled, text, begin, regexRefs) => {
+  const match = regexCompiledFindEx(_, compiled, text, begin, regexRefs);
   if (match === undefined) {
     // We could just fail on `undefined.groups`, but that seems accidental.
     throw Error();
   }
-  return match.groups;
-}
+  return match;
+};
 
 /**
  * @param {RegExp} compiled
  * @param {string} text
+ * @param {number} begin
  */
-function regexCompiledFindEx(_, compiled, text, regexRefs) {
+function regexCompiledFindEx(_, compiled, text, begin, regexRefs) {
+  compiled.lastIndex = begin;
   const match = compiled.exec(text);
   if (match === null) {
     return undefined;
   }
-  const { groups: groupsMaybe, indices: { groups: indexGroupsMaybe } } = match;
+  const {
+    // @ts-ignore
+    groups: groupsMaybe,
+    // @ts-ignore
+    indices: { groups: indexGroupsMaybe },
+  } = match;
   const groups = groupsMaybe || {};
-  const indexGroups = indexGroupsMaybe || [];
+  const indexGroups = indexGroupsMaybe || {};
   // Find the begin indices in code points for all matched groups.
-  const rawBegins = [];
-  const defaultFull = !("full" in groups);
-  if (defaultFull) {
-    rawBegins.push({ name: "full", index: match.index });
-  }
-  for (const entry of Object.entries(indexGroups)) {
-    const [name, indices] = entry;
-    if (indices !== undefined) {
-      rawBegins.push({ name, index: indices[0] });
-    }
-  }
-  const begins = codePointIndices(text, rawBegins);
-  // Form the matches.
-  const Group = regexRefs.group.constructor;
+  const Match = regexRefs.match.constructor;
+  const Group = regexRefs.match.full.constructor;
   const resultGroups = new Map();
-  if (defaultFull) {
-    resultGroups.set("full", new Group("full", match[0], begins.full));
-  }
-  for (const entry of Object.entries(groups)) {
-    const [name, value] = entry;
-    resultGroups.set(name, new Group(name, value ?? "", begins[name] ?? -1));
-  }
-  return { groups: resultGroups, index: match.index, length: match[0].length };
-}
-
-function codePointIndices(text, unitNameIndexArray) {
-  // Follows logic from CodePointsStringSlice but simpler.
-  // Sort first for single pass O(m log m) + O(n) rather than O(m * n).
-  // TODO(tjp, regex): Can we presume we often receive them in sorted order?
-  unitNameIndexArray.sort((a, b) => a.index - b.index);
-  let unitCount = 0;
-  let codeCount = 0;
-  const codeIndices = {};
-  for (const unitNameIndex of unitNameIndexArray) {
-    const { name, index: unitIndex } = unitNameIndex;
-    while (unitCount < unitIndex) {
-      unitCount += text.codePointAt(unitCount) > 0xFFFF ? 2 : 1;
-      codeCount += 1;
+  const fullText = match[0];
+  const fullBegin = match.index;
+  const full = new Group(
+    "full",
+    fullText,
+    fullBegin,
+    fullBegin + fullText.length
+  );
+  for (const name of Object.keys(indexGroups)) {
+    const indices = indexGroups[name];
+    const text = groups[name];
+    if (text === undefined) {
+      continue;
     }
-    codeIndices[name] = codeCount;
+    const groupBegin = indices[0];
+    resultGroups.set(
+      name,
+      new Group(name, text, groupBegin, groupBegin + text.length)
+    );
   }
-  return codeIndices;
+  return new Match(full, resultGroups);
 }
 
 /**
@@ -74,36 +71,56 @@ function codePointIndices(text, unitNameIndexArray) {
  * @param {(groups: Map<string, any>) => string} format
  * @returns {string}
  */
-export function regexCompiledReplace(
-  _,
-  compiled,
-  text,
-  format,
-  regexRefs
-) {
+export const regexCompiledReplace = (_, compiled, text, format, regexRefs) => {
   // Simple string replace doesn't provide all match group details if we want to
   // make our interface consistent, so we have to do this manually here.
   // The hope is that we can optimize a bunch out when we have compile-time
   // contant patterns and customized match result types.
-  let match = regexCompiledFindEx(_, compiled, text, regexRefs);
-  if (match === undefined) {
-    // Manually handle no match case for our manual replace logic.
-    return text;
-  }
-  // Index and length in js space should save some processing.
-  const { groups, index, length } = match;
-  const content = format(groups);
-  return text.slice(0, index) + content + text.slice(index + length);
-}
+  let result = "";
+  let begin = 0;
+  let keepBegin = begin;
+  do {
+    let match = regexCompiledFindEx(_, compiled, text, begin, regexRefs);
+    if (match === undefined) {
+      if (result == "") {
+        // Manually handle no match case for our manual replace logic.
+        return text;
+      } else {
+        result += text.substring(keepBegin);
+        break;
+      }
+    }
+    result += text.slice(keepBegin, match.full.begin);
+    result += format(match);
+    keepBegin = match.full.end;
+    begin = Math.max(keepBegin, begin + 1);
+  } while (begin <= text.length); // `<=` to see string end
+  return result;
+};
 
-export function regexCompileFormatted(_, formatted) {
-  return new RegExp(formatted, "du"); // d:hasIndices, u:unicode
-}
+/**
+ * @param {RegExp} compiled
+ * @param {string} text
+ * @returns {Readonly<string[]>}
+ */
+export const regexCompiledSplit = (_, compiled, text) => {
+  return Object.freeze(text.split(compiled));
+};
 
-export function regexFormatterAdjustCodeSet(self, codeSet, regexRefs) {
+/**
+ * @param {RegExp} _
+ * @param {string} formatted
+ * @returns {RegExp}
+ */
+export const regexCompileFormatted = (_, formatted) => {
+  return new RegExp(formatted, "dgu"); // d:hasIndices, g:global, u:unicode
+};
+
+export const regexFormatterAdjustCodeSet = (self, codeSet, regexRefs) => {
   if (codeSet.negated) {
     let maxCode = codeSet.items.reduce(
-      (maxCode, item) => Math.max(maxCode, self.maxCode(item)) ?? 0, 0
+      (maxCode, item) => Math.max(maxCode, self.maxCode(item)) ?? 0,
+      0
     );
     if (maxCode < MIN_SUPPLEMENTAL_CP) {
       // Add a bonus explicit surrogate pair to encourage js code points.
@@ -115,20 +132,18 @@ export function regexFormatterAdjustCodeSet(self, codeSet, regexRefs) {
       }
       return new regexRefs.orObject.constructor([
         codeSetBonus,
-        new codeSet.constructor(
-          [codeSetBonus].concat(codeSet.items), true
-        ),
+        new codeSet.constructor([codeSetBonus].concat(codeSet.items), true),
       ]);
     }
   }
   return codeSet;
-}
+};
 
-export function regexFormatterPushCodeTo(_, out, code, insideCodeSet) {
+export const regexFormatterPushCodeTo = (_, out, code, insideCodeSet) => {
   // Ignore insideCodeSet for now.
   // TODO(tjp, regex): Get fancier, including with work in Temper.
   out.push(`\\u{${code.toString(16)}}`);
-}
+};
 
 // Cached later for some approximate efficiency.
 let codeSetBonus = null;

package/string.js

@@ -0,0 +1,198 @@
+import { requireIsSafeInteger } from "./check-type.js";
+import {bubble} from "./core.js";
+
+/**
+ * Implements extension method String::fromCodePoints
+ * @param {number[]} codePoints
+ * @returns {string}
+ */
+export const stringFromCodePoints = (codePoints) => {
+    // TODO Append in batches if codePoints is long?
+    return String.fromCodePoint(...codePoints);
+};
+
+/**
+ * Implements extension method String::isEmpty
+ * @param {string} s
+ * @returns {boolean}
+ */
+export const stringIsEmpty = (s) => {
+    return s === "";
+};
+
+/**
+ * Implements extension method String::split
+ * @param {string} s
+ * @param {string | undefined} separator
+ * @returns {string[]}
+ */
+export const stringSplit = (s, separator) => {
+    return separator ? s.split(separator).map((s) => s) : Array.from(s);
+};
+
+/**
+ * Implements extension method String::toFloat64
+ * @param {string} s
+ * @returns {number}
+ */
+export const stringToFloat64 = (s) => {
+    // TODO Consider JSON.parse + bonus constants instead? Faster or not?
+    if (!/^\s*-?(?:\d+(?:\.\d+)?(?:[eE][-+]?\d+)?|NaN|Infinity)\s*$/.test(s)) {
+        bubble();
+    }
+    return Number(s);
+};
+
+/**
+ * Implements extension method String::toInt
+ * @param {string} s
+ * @param {number?} radix
+ * @returns {number}
+ */
+export const stringToInt = (s, radix) => {
+    // This currently maybe allocates for trim and then also for check.
+    // TODO Avoid that with manual char checks? Arbitrary base makes regex harder.
+    s = s.trim();
+    radix = radix ?? 10;
+    const result = parseInt(s, radix);
+    requireIsSafeInteger(result);
+    const trimmed = s.slice(0, s.length - 1);
+    if (parseInt(trimmed, radix) === result) {
+        bubble();
+    }
+    return result;
+};
+
+/**
+ * @param {string} s
+ * @param {number} begin
+ * @param {number} end
+ * @returns {number}
+ */
+export const stringCountBetween = (s, begin, end) => {
+    let count = 0;
+    for (let i = begin; i < end; ++i) {
+        let cp = s.codePointAt(i);
+        if (cp !== undefined) {
+            count += 1;
+            i += !!(cp >>> 16); // skip over trailing surrogate
+        }
+    }
+    return count;
+};
+
+/**
+ * @param {string} s
+ * @param {number} i
+ * @returns {number}
+ */
+export const stringGet = (s, i) => {
+    const c = s.codePointAt(i);
+    if (c === undefined) {
+        throw new Error();
+    }
+    return c;
+};
+
+/**
+ * @param {string} s
+ * @param {number} begin
+ * @param {number} end
+ * @param {number} minCount
+ * @returns {boolean}
+ */
+export const stringHasAtLeast = (s, begin, end, minCount) => {
+    let { length } = s;
+    begin = Math.min(begin, length);
+    end = Math.max(begin, Math.min(end, length));
+    let nUtf16 = end - begin;
+    if (nUtf16 < minCount) { return false; }
+    if (nUtf16 >= minCount * 2) { return true; }
+    // Fall back to an early-outing version of countBetween.
+    let count = 0;
+    for (let i = begin; i < end; ++i) {
+        let cp = s.codePointAt(i);
+        if (cp !== undefined) {
+            count += 1;
+            i += !!(cp >>> 16); // skip over trailing surrogate
+            if (count >= minCount) { return true; }
+        }
+    }
+    return count >= minCount;
+};
+
+/**
+ * @param {string} s
+ * @param {number} i
+ * @returns {number}
+ */
+export const stringNext = (s, i) => {
+    let iNext = Math.min(s.length, i);
+    let cp = s.codePointAt(i);
+    if (cp !== undefined) {
+        iNext += 1 + !!(cp >>> 16);
+    }
+    return iNext;
+};
+
+/**
+ * @param {string} s
+ * @param {number} i
+ * @returns {number}
+ */
+export const stringPrev = (s, i) => {
+    let iPrev = Math.min(s.length, i);
+    if (iPrev) {
+        iPrev -= 1;
+        if (iPrev && s.codePointAt(iPrev - 1) >>> 16) {
+            iPrev -= 1;
+        }
+    }
+    return iPrev;
+};
+
+/**
+ * @param {string} s
+ * @param {(number) => void} f
+ */
+export const stringForEach = (s, f) => {
+    let { length } = s;
+    for (let i = 0; i < length; ++i) {
+        let cp = s.codePointAt(i);
+        f(cp);
+        if (cp >>> 16) {
+            ++i; // Skip both surrogates
+        }
+    }
+};
+
+export const stringIndexNone = -1;
+
+/**
+ * Casts a *StringIndexOption* to a *StringIndex*
+ *
+ * @param {number} i a string index or no string index
+ * @returns {number} i if it's a valid StringIndex.
+ */
+export const requireStringIndex = (i) => {
+    if (i >= 0) { return i; }
+    throw new TypeError(`Expected StringIndex, not ${i}`);
+};
+
+/**
+ * Casts a *StringIndexOption* to a *NoStringIndex*.
+ * @param {number} i a string index or no string index
+ * @returns {number} i if it's valid NoStringIndex.
+ */
+export const requireNoStringIndex = (i) => {
+    if (i < 0) { return i; }
+    throw new TypeError(`Expected NoStringIndex, not ${i}`);
+};
+
+/**
+ * @param {string[]} s
+ * @param {number} c
+ */
+export const stringBuilderAppendCodePoint = (s, c) => {
+    s[0] += String.fromCodePoint(c);
+}

package/interface-types.js

@@ -1,121 +0,0 @@
-/**
- * @fileoverview
- * Declares *InterfaceType* which allows exposing a Temper `interface` type
- * as a type that user types can extend and which inter-operates with
- * `instanceof`.
- *
- * User code may do
- *
- *     MyClass.implementedBy(AnInterface);
- *
- * to declare that `class MyClass implements AnInterface { ... }`.
- *
- * After that, members defined on *AnInterface* will be available via
- * *MyClass*'s prototype and `new MyClass(...) instanceof AnInterface` will
- * be true.
- */
-
-export class InterfaceType {
-    constructor(name, members, supers, inheritanceDepth) {
-        /** Diagnostic string.  The name of the interface. */
-        this.name = name;
-        /**
-         * A list of [kind, propertyKey, value] triples that should be added to
-         * classes that implement this modulo overriding.
-         * Kind has type ("m" | "g" | "s") where "m" indicates a normal method
-         * whose name is key, "g" a getter for the property named key,
-         * and "s" a setter.
-         */
-        this.members = [...members];
-        /** interface types that are super-types of this */
-        this.supers = [...supers];
-        /**
-         * Computed by Temper compiler so that sub-type members can clobber
-         * super-type members but not otherwise.
-         */
-        this.inheritanceDepth = inheritanceDepth;
-        /** Presence `in` a value indicates sub-type. */
-        this.interfaceTag = Symbol(this.toString());
-    }
-
-    toString() { return `interface ${this.name}`; }
-
-    /** Invoked when user code does `value instanceof anInterfaceType`. */
-    [Symbol.hasInstance](x) {
-        return x && typeof x === 'object' && this.interfaceTag in x;
-    }
-
-    /** Called to declare a class implements this InterfaceType. */
-    implementedBy(classType) {
-        const memberMaps = InterfaceType.#memberMapsFor(classType);
-        classType.prototype[this.interfaceTag] = void 0;
-        const inheritanceDepth = this.inheritanceDepth;
-        for (const [kind, key, value] of this.members) {
-            const memberMap = memberMaps[kind];
-            const depth = memberMap.get(key);
-            if (typeof depth === 'undefined' || inheritanceDepth > depth) {
-                memberMap.set(key, inheritanceDepth);
-                const proto = classType.prototype;
-                const descriptor = Object.getOwnPropertyDescriptor(proto, key)
-                    || { configurable: true };
-                switch (kind) {
-                    case 'm':
-                       descriptor.value = value;
-                       break;
-                    case 'g':
-                       descriptor.get = value;
-                       break;
-                    case 's':
-                       descriptor.set = value;
-                       break;
-                }
-                Object.defineProperty(proto, key, descriptor);
-            }
-        }
-        for (const superType of this.supers) {
-            superType.implementedBy(classType);
-        }
-    }
-
-    static #memberMapsKey = Symbol('memberMaps');
-
-    static #memberMapsFor(classType) {
-        const memberMapsKey = InterfaceType.#memberMapsKey;
-        // Do not reuse super-class's member map
-        let maps = Object.hasOwnProperty.call(classType, memberMapsKey)
-            ? classType[memberMapsKey] : null;
-        if (!maps) {
-            maps = { m: new Map(), g: new Map(), s: new Map() };
-            classType[memberMapsKey] = maps;
-            // Walk prototypes.  Even though Temper does not allow class
-            // inheritance, this code may be used by JavaScript types that
-            // do, so flatten class members so that interfaces don't clobber
-            // class members.
-            // Except we treat interfaces as sub-types of Object, so stop
-            // before Object.prototype.  This allows an interface to override
-            // Object members like toString, valueOf, etc.
-            let prototype = classType.prototype;
-            while (prototype && prototype !== Object.prototype) {
-                for (const keys of [
-                    Object.getOwnPropertyNames(prototype),
-                    Object.getOwnPropertySymbols(prototype),
-                ]) {
-                    for (const key of keys) {
-                        const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
-                        if ('value' in descriptor) {
-                            maps.m.set(key, Number.MAX_SAFE_INTEGER);
-                        }
-                        if (descriptor.get) {
-                            maps.g.set(key, Number.MAX_SAFE_INTEGER);
-                        }
-                        if (descriptor.set) {
-                            maps.s.set(key, Number.MAX_SAFE_INTEGER);
-                        }
-                    }
-                }
-                prototype = Object.getPrototypeOf(prototype);
-            }
-        }
-        return maps;
-    }
-}