Merge pull request #1388 from benjamn/tiny-invariant

refactor: replace `assert` with `tiny-invariant`

lib/comments.ts

@@ -1,4 +1,4 @@
-import assert from "assert";
+import invariant from "tiny-invariant";
 import * as types from "ast-types";
 const n = types.namedTypes;
 const isArray = types.builtInTypes.array;
@@ -147,9 +147,9 @@ export function attach(comments: any[], ast: any, lines: any) {
       if (tieCount > 0) {
         const lastTie = tiesToBreak[tieCount - 1];
 
-        assert.strictEqual(
-          lastTie.precedingNode === comment.precedingNode,
-          lastTie.followingNode === comment.followingNode,
+        invariant(
+          (lastTie.precedingNode === comment.precedingNode) ===
+            (lastTie.followingNode === comment.followingNode),
         );
 
         if (lastTie.followingNode !== comment.followingNode) {
@@ -206,8 +206,8 @@ function breakTies(tiesToBreak: any[], lines: any) {
   let comment;
   for (; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
     comment = tiesToBreak[indexOfFirstLeadingComment - 1];
-    assert.strictEqual(comment.precedingNode, pn);
-    assert.strictEqual(comment.followingNode, fn);
+    invariant(comment.precedingNode === pn);
+    invariant(comment.followingNode === fn);
 
     const gap = lines.sliceString(comment.loc.end, gapEndPos);
     if (/\S/.test(gap)) {

lib/fast-path.ts

@@ -1,4 +1,4 @@
-import assert from "assert";
+import invariant from "tiny-invariant";
 import * as types from "ast-types";
 import * as util from "./util";
 
@@ -52,7 +52,7 @@ interface FastPathConstructor {
 }
 
 const FastPath = function FastPath(this: FastPathType, value: any) {
-  assert.ok(this instanceof FastPath);
+  invariant(this instanceof FastPath);
   this.stack = [value];
 } as any as FastPathConstructor;
 
@@ -402,7 +402,7 @@ FPp.needsParens = function (assumeExpressionContext) {
           }
 
           if (pp === np && name === "right") {
-            assert.strictEqual(parent.right, node);
+            invariant(parent.right === node);
             return true;
           }
 
@@ -636,22 +636,22 @@ FPp.firstInStatement = function () {
       parentName === "body" &&
       childName === 0
     ) {
-      assert.strictEqual(parent.body[0], child);
+      invariant(parent.body[0] === child);
       return true;
     }
 
     if (n.ExpressionStatement.check(parent) && childName === "expression") {
-      assert.strictEqual(parent.expression, child);
+      invariant(parent.expression === child);
       return true;
     }
 
     if (n.AssignmentExpression.check(parent) && childName === "left") {
-      assert.strictEqual(parent.left, child);
+      invariant(parent.left === child);
       return true;
     }
 
     if (n.ArrowFunctionExpression.check(parent) && childName === "body") {
-      assert.strictEqual(parent.body, child);
+      invariant(parent.body === child);
       return true;
     }
 
@@ -662,27 +662,27 @@ FPp.firstInStatement = function () {
       s[i + 1] === "expressions" &&
       childName === 0
     ) {
-      assert.strictEqual(parent.expressions[0], child);
+      invariant(parent.expressions[0] === child);
       continue;
     }
 
     if (n.CallExpression.check(parent) && childName === "callee") {
-      assert.strictEqual(parent.callee, child);
+      invariant(parent.callee === child);
       continue;
     }
 
     if (n.MemberExpression.check(parent) && childName === "object") {
-      assert.strictEqual(parent.object, child);
+      invariant(parent.object === child);
       continue;
     }
 
     if (n.ConditionalExpression.check(parent) && childName === "test") {
-      assert.strictEqual(parent.test, child);
+      invariant(parent.test === child);
       continue;
     }
 
     if (isBinary(parent) && childName === "left") {
-      assert.strictEqual(parent.left, child);
+      invariant(parent.left === child);
       continue;
     }
 
@@ -691,7 +691,7 @@ FPp.firstInStatement = function () {
       !parent.prefix &&
       childName === "argument"
     ) {
-      assert.strictEqual(parent.argument, child);
+      invariant(parent.argument === child);
       continue;
     }
 

lib/lines.ts

@@ -1,4 +1,4 @@
-import assert from "assert";
+import invariant from "tiny-invariant";
 import sourceMap from "source-map";
 import { normalize as normalizeOptions, Options } from "./options";
 import { namedTypes } from "ast-types";
@@ -30,7 +30,7 @@ export class Lines {
   private cachedTabWidth: number | void = void 0;
 
   constructor(private infos: LineInfo[], sourceFileName: string | null = null) {
-    assert.ok(infos.length > 0);
+    invariant(infos.length > 0);
     this.length = infos.length;
     this.name = sourceFileName || null;
 
@@ -96,7 +96,7 @@ export class Lines {
       ) {
         const sourceChar = mapping.sourceLines.charAt(sourceCursor);
         const targetChar = targetLines.charAt(targetCursor);
-        assert.strictEqual(sourceChar, targetChar);
+        invariant(sourceChar === targetChar);
 
         const sourceName = mapping.sourceLines.name;
 
@@ -124,9 +124,9 @@ export class Lines {
   }
 
   bootstrapCharAt(pos: Pos) {
-    assert.strictEqual(typeof pos, "object");
-    assert.strictEqual(typeof pos.line, "number");
-    assert.strictEqual(typeof pos.column, "number");
+    invariant(typeof pos === "object");
+    invariant(typeof pos.line === "number");
+    invariant(typeof pos.column === "number");
 
     const line = pos.line,
       column = pos.column,
@@ -143,9 +143,9 @@ export class Lines {
   }
 
   charAt(pos: Pos) {
-    assert.strictEqual(typeof pos, "object");
-    assert.strictEqual(typeof pos.line, "number");
-    assert.strictEqual(typeof pos.column, "number");
+    invariant(typeof pos === "object");
+    invariant(typeof pos.line === "number");
+    invariant(typeof pos.column === "number");
 
     let line = pos.line,
       column = pos.column,
@@ -171,7 +171,7 @@ export class Lines {
   stripMargin(width: number, skipFirstLine: boolean) {
     if (width === 0) return this;
 
-    assert.ok(width > 0, "negative margin: " + width);
+    invariant(width > 0, "negative margin: " + width);
 
     if (skipFirstLine && this.length === 1) return this;
 
@@ -189,7 +189,7 @@ export class Lines {
 
     if (this.mappings.length > 0) {
       const newMappings = lines.mappings;
-      assert.strictEqual(newMappings.length, 0);
+      invariant(newMappings.length === 0);
       this.mappings.forEach(function (mapping: any) {
         newMappings.push(mapping.indent(width, skipFirstLine, true));
       });
@@ -217,7 +217,7 @@ export class Lines {
 
     if (this.mappings.length > 0) {
       const newMappings = lines.mappings;
-      assert.strictEqual(newMappings.length, 0);
+      invariant(newMappings.length === 0);
       this.mappings.forEach(function (mapping: any) {
         newMappings.push(mapping.indent(by));
       });
@@ -250,7 +250,7 @@ export class Lines {
 
     if (this.mappings.length > 0) {
       const newMappings = lines.mappings;
-      assert.strictEqual(newMappings.length, 0);
+      invariant(newMappings.length === 0);
       this.mappings.forEach(function (mapping: any) {
         newMappings.push(mapping.indent(by, true));
       });
@@ -273,7 +273,7 @@ export class Lines {
   }
 
   getIndentAt(line: number) {
-    assert.ok(line >= 1, "no line " + line + " (line numbers start from 1)");
+    invariant(line >= 1, "no line " + line + " (line numbers start from 1)");
     return Math.max(this.infos[line - 1].indent, 0);
   }
 
@@ -525,7 +525,7 @@ export class Lines {
     if (start.line === end.line) {
       sliced[0] = sliceInfo(sliced[0], start.column, end.column);
     } else {
-      assert.ok(start.line < end.line);
+      invariant(start.line < end.line);
       sliced[0] = sliceInfo(sliced[0], start.column);
       sliced.push(sliceInfo(sliced.pop(), 0, end.column));
     }
@@ -534,7 +534,7 @@ export class Lines {
 
     if (this.mappings.length > 0) {
       const newMappings = lines.mappings;
-      assert.strictEqual(newMappings.length, 0);
+      invariant(newMappings.length === 0);
       this.mappings.forEach(function (this: any, mapping: any) {
         const sliced = mapping.slice(this, start, end);
         if (sliced) {
@@ -695,7 +695,7 @@ export class Lines {
   concat(...args: (string | Lines)[]) {
     const list: typeof args = [this];
     list.push.apply(list, args);
-    assert.strictEqual(list.length, args.length + 1);
+    invariant(list.length === args.length + 1);
     return emptyLines.join(list);
   }
 }
@@ -712,8 +712,8 @@ export function countSpaces(spaces: any, tabWidth?: number) {
     switch (spaces.charCodeAt(i)) {
       case 9: {
         // '\t'
-        assert.strictEqual(typeof tabWidth, "number");
-        assert.ok(tabWidth! > 0);
+        invariant(typeof tabWidth === "number");
+        invariant(tabWidth! > 0);
 
         const next = Math.ceil(count / tabWidth!) * tabWidth!;
         if (next === count) {
@@ -761,7 +761,7 @@ export function fromString(string: string | Lines, options?: Options): Lines {
   const tabless = string.indexOf("\t") < 0;
   const cacheable = !options && tabless && string.length <= maxCacheKeyLen;
 
-  assert.ok(
+  invariant(
     tabWidth || tabless,
     "No tab width specified but encountered tabs in string\n" + string,
   );
@@ -826,9 +826,9 @@ function sliceInfo(info: any, startCol: number, endCol?: number) {
     sliceStart += startCol;
   }
 
-  assert.ok(indent >= 0);
-  assert.ok(sliceStart <= sliceEnd);
-  assert.strictEqual(lineLength, indent + sliceEnd - sliceStart);
+  invariant(indent >= 0);
+  invariant(sliceStart <= sliceEnd);
+  invariant(lineLength === indent + sliceEnd - sliceStart);
 
   if (
     info.indent === indent &&

lib/mapping.ts

@@ -1,4 +1,4 @@
-import assert from "assert";
+import invariant from "tiny-invariant";
 import { comparePos } from "./util";
 import { namedTypes } from "ast-types";
 import { Lines } from "./lines";
@@ -26,7 +26,7 @@ export default class Mapping {
       if (name === "end") {
         targetToPos = end;
       } else {
-        assert.strictEqual(name, "start");
+        invariant(name === "start");
       }
 
       return skipChars(
@@ -194,17 +194,16 @@ function skipChars(
       sourceCursor.column = 0;
       targetCursor.column = 0;
     } else {
-      assert.strictEqual(lineDiff, 0);
+      invariant(lineDiff === 0);
     }
 
     while (
       comparePos(targetCursor, targetToPos) < 0 &&
       targetLines.nextPos(targetCursor, true)
     ) {
-      assert.ok(sourceLines.nextPos(sourceCursor, true));
-      assert.strictEqual(
-        sourceLines.charAt(sourceCursor),
-        targetLines.charAt(targetCursor),
+      invariant(sourceLines.nextPos(sourceCursor, true));
+      invariant(
+        sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor),
       );
     }
   } else {
@@ -224,17 +223,16 @@ function skipChars(
       sourceCursor.column = sourceLines.getLineLength(sourceCursor.line);
       targetCursor.column = targetLines.getLineLength(targetCursor.line);
     } else {
-      assert.strictEqual(lineDiff, 0);
+      invariant(lineDiff === 0);
     }
 
     while (
       comparePos(targetToPos, targetCursor) < 0 &&
       targetLines.prevPos(targetCursor, true)
     ) {
-      assert.ok(sourceLines.prevPos(sourceCursor, true));
-      assert.strictEqual(
-        sourceLines.charAt(sourceCursor),
-        targetLines.charAt(targetCursor),
+      invariant(sourceLines.prevPos(sourceCursor, true));
+      invariant(
+        sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor),
       );
     }
   }

lib/parser.ts

@@ -1,4 +1,4 @@
-import assert from "assert";
+import invariant from "tiny-invariant";
 import * as types from "ast-types";
 const b = types.builders;
 const isObject = types.builtInTypes.object;
@@ -143,7 +143,7 @@ const TreeCopier = function TreeCopier(
   lines: any,
   tokens: any,
 ) {
-  assert.ok(this instanceof TreeCopier);
+  invariant(this instanceof TreeCopier);
   this.lines = lines;
   this.tokens = tokens;
   this.startTokenIndex = 0;