tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/link-tables.js

@@ -170,19 +170,23 @@ export class PagedIdSet {
 }
 /** The number of set bits of a 32-bit value. */
 function bitCount(x) {
-    x = x - ((x >>> 1) & 0x55555555);
+    x = (x - ((x >>> 1) & 0x55555555)) | 0;
     x = (x & 0x33333333) + ((x >>> 2) & 0x33333333);
     x = (x + (x >>> 4)) & 0x0f0f0f0f;
-    return Math.imul(x, 0x01010101) >>> 24;
+    // At most 32, so the top byte is the count with either shift; `>>` keeps it an int32.
+    return Math.imul(x, 0x01010101) >> 24;
 }
 /**
- * A page of a `CompactSymbolLinkTable`: one bit per id of the page in eight 32-id words, the number
- * of symbols stored before each word, and the symbols in id order. The words are fields, so a
- * lookup reads one object before the symbols. The class isn't generic, so natively the words are
- * 32-bit fields: every write stores an int32.
+ * A page of a `CompactLinkTable`'s presence bits: one bit per id of the page in eight 32-id words, the
+ * number of values stored before each word, and the position of the page's values in the table's
+ * `values`. The words are fields, so a lookup reads one object before the values. Natively the words
+ * are 32-bit fields, since every write stores an int32. A class that is generic or has a generic
+ * subclass keeps its number fields as doubles, so the values the bits index are in the table's
+ * `values`, not in this class or a subclass.
  */
 class CompactLinkPage {
-    values;
+    /** The position of the page's values in the table's `values`. */
+    position;
     w0;
     w1;
     w2;
@@ -194,8 +198,8 @@ class CompactLinkPage {
     /** Byte `w & 3` of `before0` (words 1 to 3) or of `before1` (words 4 to 7): the values before word `w`. */
     before0;
     before1;
-    constructor() {
-        this.values = [];
+    constructor(position) {
+        this.position = position | 0;
         this.w0 = 0;
         this.w1 = 0;
         this.w2 = 0;
@@ -259,40 +263,55 @@ class CompactLinkPage {
     rank(slot, bits) {
         const word = slot >> 5;
         const before = ((word < 4 ? this.before0 : this.before1) >>> ((word & 3) << 3)) & 0xff;
-        return before + bitCount(bits & ((1 << (slot & 31)) - 1));
+        return (before + bitCount(bits & ((1 << (slot & 31)) - 1))) | 0;
     }
-    /** Adds `delta` to the counts of the words after `word`. */
+    /**
+     * Adds 1 (`delta` 1) or subtracts 1 (`delta` -1) from the counts of the words after `word`, a byte
+     * of `before0` or `before1` each. No byte carries or borrows: a count is at most 224, and a count
+     * that goes down includes the value removed.
+     */
     shiftCounts(word, delta) {
-        for (let w = word + 1; w < 8; w++) {
-            const step = delta << ((w & 3) << 3);
-            if (w < 4)
-                this.before0 = (this.before0 + step) | 0;
-            else
-                this.before1 = (this.before1 + step) | 0;
-        }
+        // A 1 in each byte of the words after `word`: shifting `0x01010100` left by `word` bytes keeps
+        // the bytes above it, and shifts them all out at word 3.
+        const low = word < 4 ? 0x01010100 << (word << 3) : 0;
+        const high = word < 4 ? 0x01010101 : 0x01010100 << ((word & 3) << 3);
+        this.before0 = (this.before0 + Math.imul(low, delta)) | 0;
+        this.before1 = (this.before1 + Math.imul(high, delta)) | 0;
     }
 }
 /**
- * Symbols by node id, for ids a checker resolves in one in four to one in eight of the ids of the
- * pages it touches, as it resolves the identifiers and names of the files it checks. Pages of
- * `LinkPaging.Size` ids keep a presence bit per id and only the symbols stored, so a symbol costs
- * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also
- * stores its key and a share of the hash buckets. At fewer values per page than that, the page's
- * own allocations outweigh what it saves, and a `SparseLinkTable` costs less.
+ * Values by node or symbol id, for ids a checker stores a value for in more than about one in
+ * sixteen of the ids of the pages it touches: the symbols it resolves for the identifiers and names
+ * of the files it checks (one in four to one in eight), the types and signatures it resolves for
+ * their type nodes and calls (one in twelve to one in seventeen), and the symbol columns most
+ * symbols leave empty, such as the name type of a property (one in ten to one in three with
+ * `--checkers 16`, where every checker touches symbols across the whole program). Pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the values stored, so a value costs
+ * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also stores
+ * its key and a share of the hash buckets. At fewer values per page than that, the page's own
+ * allocations outweigh what it saves, and a `SparseLinkTable` costs less.
  */
-export class CompactSymbolLinkTable {
+export class CompactLinkTable {
+    /**
+     * The pages by `id >> LinkPaging.Bits`, up to the highest page stored; undefined where a page stores
+     * nothing. A checker stores values in a few percent of the pages of a large program, so the values
+     * are kept apart, one list for each page stored, rather than in a second slot per page.
+     */
     pages = [];
-    /** The number of symbols stored. */
+    /** The values of each page stored, in id order, at the page's `position`. */
+    values = [];
+    /** The number of values stored. */
     size = 0;
     get(id) {
-        const page = this.pages[id >> 8 /* LinkPaging.Bits */];
+        const index = id >> 8 /* LinkPaging.Bits */;
+        const page = this.pages[index];
         if (page === undefined)
             return undefined;
         const slot = id & 255 /* LinkPaging.Mask */;
         const bits = page.word(slot >> 5);
         if ((bits & (1 << (slot & 31))) === 0)
             return undefined;
-        return page.values[page.rank(slot, bits)];
+        return this.values[page.position][page.rank(slot, bits)];
     }
     set(id, value) {
         const index = id >> 8 /* LinkPaging.Bits */;
@@ -302,23 +321,25 @@ export class CompactSymbolLinkTable {
                 return;
             while (this.pages.length <= index)
                 this.pages.push(undefined);
-            page = new CompactLinkPage();
+            page = new CompactLinkPage(this.values.length);
             this.pages[index] = page;
+            this.values.push([]);
         }
+        const values = this.values[page.position];
         const slot = id & 255 /* LinkPaging.Mask */;
         const word = slot >> 5;
         const bit = 1 << (slot & 31);
         const bits = page.word(word);
         const at = page.rank(slot, bits);
-        const values = page.values;
         if ((bits & bit) !== 0) {
             if (value !== undefined) {
                 values[at] = value;
                 return;
             }
-            for (let i = at; i < values.length - 1; i++)
-                values[i] = values[i + 1];
-            values.pop();
+            if (at === values.length - 1)
+                values.pop();
+            else
+                values.splice(at, 1);
             page.setWord(word, bits & ~bit);
             page.shiftCounts(word, -1);
             this.size--;
@@ -326,16 +347,38 @@ export class CompactSymbolLinkTable {
         }
         if (value === undefined)
             return;
-        values.push(value);
-        for (let i = values.length - 1; i > at; i--)
-            values[i] = values[i - 1];
-        values[at] = value;
+        // Values are mostly stored in id order, at the end.
+        if (at === values.length)
+            values.push(value);
+        else
+            values.splice(at, 0, value);
         page.setWord(word, bits | bit);
         page.shiftCounts(word, 1);
         this.size++;
     }
     clear() {
         this.pages.length = 0;
+        this.values.length = 0;
         this.size = 0;
     }
 }
+/**
+ * Int32 values by id, zero where none is stored, in a `CompactLinkTable`: pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the nonzero values. For columns where a
+ * checker stores a value for fewer than about one in three of the ids of the pages it touches, such
+ * as the reference kinds of the symbols its files reference: an `IntLinkTable` page costs four bytes
+ * for every id.
+ */
+export class CompactIntLinkTable {
+    table = new CompactLinkTable();
+    get(id) {
+        return this.table.get(id) ?? 0;
+    }
+    set(id, value) {
+        value = value | 0;
+        this.table.set(id, value === 0 ? undefined : value);
+    }
+    clear() {
+        this.table.clear();
+    }
+}