@fimbul/mimir - npm Package Compare versions

Comparing version 0.16.0-dev.20181107 to 0.16.0-dev.20181115

package.json

 {
   "name": "@fimbul/mimir",
-  "version": "0.16.0-dev.20181107",
+  "version": "0.16.0-dev.20181115",
   "description": "Core rules of the Fimbullinter project",
@@ -28,7 +28,7 @@ "main": "recommended.yaml",
   "dependencies": {
-    "@fimbul/ymir": "0.16.0-dev.20181107",
+    "@fimbul/ymir": "0.16.0-dev.20181115",
     "chalk": "^2.3.2",
     "debug": "^4.0.0",
     "tslib": "^1.8.1",
-    "tsutils": "^3.1.0"
+    "tsutils": "^3.5.0"
   },
@@ -35,0 +35,0 @@ "peerDependencies": {

src/rules/no-duplicate-case.js

@@ -7,2 +7,3 @@ "use strict";
 const tsutils_1 = require("tsutils");
+const _3_2_1 = require("tsutils/typeguard/3.2");
 const utils_1 = require("../utils");
@@ -28,9 +29,12 @@ let Rule = class Rule extends ymir_1.AbstractRule {
                     case 1:
-                        if (valuesSeen.has(literals[0]))
-                            this.addFailureAtNode(clause.expression, `Duplicate 'case ${formatPrimitive(literals[0])}'.`);
-                        valuesSeen.add(literals[0]);
+                        if (valuesSeen.has(literals[0])) {
+                            this.addFailureAtNode(clause.expression, `Duplicate 'case ${literals[0]}'.`);
+                        }
+                        else {
+                            valuesSeen.add(literals[0]);
+                        }
                         break;
                     default:
                         if (literals.every((v) => valuesSeen.has(v)))
-                            this.addFailureAtNode(clause.expression, `Duplicate 'case ${literals.map(formatPrimitive).sort().join(' | ')}'.`);
+                            this.addFailureAtNode(clause.expression, `Duplicate 'case ${literals.sort().join(' | ')}'.`);
                 }
@@ -50,14 +54,16 @@ }
         if (tsutils_1.isTextualLiteral(node))
-            return [prefixFn(node.text)];
+            return [formatPrimitive(prefixFn(node.text))];
         if (tsutils_1.isNumericLiteral(node))
-            return [prefixFn(+node.text)];
+            return [formatPrimitive(prefixFn(+node.text))];
+        if (_3_2_1.isBigIntLiteral(node))
+            return [formatPrimitive(prefixFn({ base10Value: node.text.slice(0, -1), negative: false }))];
         if (node.kind === ts.SyntaxKind.NullKeyword)
-            return [prefixFn(null)];
+            return [formatPrimitive(prefixFn(null))];
         if (tsutils_1.isIdentifier(node) && node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword)
-            return [prefixFn(undefined)];
+            return [formatPrimitive(prefixFn(undefined))];
         if (node.kind === ts.SyntaxKind.TrueKeyword)
-            return [prefixFn(true)];
+            return [formatPrimitive(prefixFn(true))];
         if (node.kind === ts.SyntaxKind.FalseKeyword)
-            return [prefixFn(false)];
-        if (this.program === undefined)
+            return [formatPrimitive(prefixFn(false))];
+        if (this.program === undefined || !tsutils_1.isStrictCompilerOptionEnabled(this.program.getCompilerOptions(), 'strictNullChecks'))
             return [];
@@ -70,12 +76,12 @@ const checker = this.program.getTypeChecker();
             if (tsutils_1.isLiteralType(t)) {
-                result.add(prefixFn(t.value));
+                result.add(formatPrimitive(prefixFn(t.value)));
             }
             else if (t.flags & ts.TypeFlags.BooleanLiteral) {
-                result.add(prefixFn(t.intrinsicName === 'true'));
+                result.add(formatPrimitive(prefixFn(t.intrinsicName === 'true')));
             }
             else if (t.flags & ts.TypeFlags.Undefined) {
-                result.add(prefixFn(undefined));
+                result.add(formatPrimitive(prefixFn(undefined)));
             }
             else if (t.flags & ts.TypeFlags.Null) {
-                result.add(prefixFn(null));
+                result.add(formatPrimitive(prefixFn(null)));
             }
@@ -99,9 +105,9 @@ else {
         case ts.SyntaxKind.PlusToken:
-            return (v) => next(+v);
+            return (v) => isBigInt(v) ? next(v) : next(+v);
         case ts.SyntaxKind.MinusToken:
-            return (v) => next(-v);
+            return (v) => isBigInt(v) ? next(Object.assign({}, v, { negative: !v.negative && v.base10Value !== '0' })) : next(-v);
         case ts.SyntaxKind.TildeToken:
-            return (v) => next(~v);
+            return (v) => isBigInt(v) ? negateBigint(v) : next(~v);
         case ts.SyntaxKind.ExclamationToken:
-            return (v) => next(!v);
+            return (v) => isBigInt(v) ? next(v.base10Value === '0') : next(!v);
         default:
@@ -111,5 +117,45 @@ return;
 }
+function isBigInt(v) {
+    return typeof v === 'object' && v !== null;
+}
+function negateBigint(v) {
+    const digits = v.base10Value.split('');
+    if (v.negative) {
+        for (let i = digits.length - 1; i >= 0; --i) {
+            const current = +digits[i] - 1;
+            if (current !== -1) {
+                if (current === 0 && i === 0 && digits.length !== 1) {
+                    digits.shift();
+                }
+                else {
+                    digits[i] = `${current}`;
+                }
+                break;
+            }
+            digits[i] = '9';
+        }
+    }
+    else {
+        for (let i = digits.length - 1; i >= 0; --i) {
+            const current = +digits[i] + 1;
+            if (current !== 10) {
+                digits[i] = `${current}`;
+                break;
+            }
+            digits[i] = '0';
+            if (i === 0) {
+                digits.unshift('1');
+                break;
+            }
+        }
+    }
+    return { base10Value: digits.join(''), negative: !v.negative };
+}
 function formatPrimitive(v) {
-    return typeof v === 'string' ? `"${v}"` : String(v);
+    return isBigInt(v)
+        ? utils_1.formatPseudoBigInt(v)
+        : typeof v === 'string'
+            ? `"${v}"`
+            : String(v);
 }
 //# sourceMappingURL=no-duplicate-case.js.map

src/rules/no-invalid-assertion.js

@@ -7,2 +7,3 @@ "use strict";
 const ts = require("typescript");
+const utils_1 = require("../utils");
 let Rule = class Rule extends ymir_1.TypedRule {
@@ -43,2 +44,4 @@ apply() {
         result.push(Array.from(literals.number).join(' | '));
+    if (literals.bigint !== undefined)
+        result.push(Array.from(literals.bigint).join(' | '));
     if (literals.boolean !== undefined)
@@ -53,2 +56,4 @@ result.push(`${literals.boolean}`);
         a.number = b.number = undefined;
+    if (a.bigint === undefined || b.bigint === undefined || intersects(a.bigint, b.bigint))
+        a.bigint = b.bigint = undefined;
     if (a.boolean === undefined || b.boolean === undefined || a.boolean === b.boolean)
@@ -64,3 +69,6 @@ a.boolean = b.boolean = undefined;
 function isEmpty(literals) {
-    return literals.string === undefined && literals.number === undefined && literals.boolean === undefined;
+    return literals.string === undefined &&
+        literals.number === undefined &&
+        literals.bigint === undefined &&
+        literals.boolean === undefined;
 }
@@ -71,2 +79,3 @@ function getLiteralsByType(type) {
         number: undefined,
+        bigint: undefined,
         boolean: undefined,
@@ -76,2 +85,3 @@ };
     let seenNumber = false;
+    let seenBigint = false;
     let seenBoolean = false;
@@ -87,2 +97,6 @@ for (const t of typeParts(type)) {
         }
+        else if (t.flags & ts.TypeFlags.BigIntLiteral) {
+            if (!seenBigint)
+                result.bigint = append(result.bigint, utils_1.formatPseudoBigInt(t.value));
+        }
         else if (t.flags & ts.TypeFlags.BooleanLiteral) {
@@ -108,2 +122,6 @@ if (!seenBoolean) {
         }
+        else if (t.flags & ts.TypeFlags.BigInt) {
+            result.bigint = undefined;
+            seenBigint = true;
+        }
     }
@@ -110,0 +128,0 @@ return result;

src/rules/no-useless-predicate.js

@@ -7,4 +7,4 @@ "use strict";
 const tsutils_1 = require("tsutils");
-const primitiveFlags = ts.TypeFlags.BooleanLike | ts.TypeFlags.NumberLike | ts.TypeFlags.StringLike | ts.TypeFlags.ESSymbolLike |
-    ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+const primitiveFlags = ts.TypeFlags.BigIntLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.NumberLike | ts.TypeFlags.StringLike |
+    ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
 const predicates = {
@@ -21,2 +21,6 @@ object: {
     },
+    bigint: {
+        nullable: false,
+        check: checkFlags(ts.TypeFlags.BigIntLike),
+    },
     string: {
@@ -169,2 +173,3 @@ nullable: false,
                 case 'undefined':
+                case 'bigint':
                     predicate = predicates[literal];
@@ -171,0 +176,0 @@ }

src/utils.d.ts

@@ -32,1 +32,2 @@ import * as ts from 'typescript';
 export declare function hasDirectivePrologue(node: ts.Node): node is ts.BlockLike;
+export declare function formatPseudoBigInt(v: ts.PseudoBigInt): string;

src/utils.js

@@ -207,2 +207,6 @@ "use strict";
 exports.hasDirectivePrologue = hasDirectivePrologue;
+function formatPseudoBigInt(v) {
+    return `${v.negative ? '-' : ''}${v.base10Value}n`;
+}
+exports.formatPseudoBigInt = formatPseudoBigInt;
 //# sourceMappingURL=utils.js.map

No alert changes

Improved metrics

Total package byte prevSize

428760

increased by1.4%

Lines of code

4314

increased by1.75%

Dependency changes

• + Added@fimbul/ymir@0.16.0-dev.20181115(transitive)

• - Removed@fimbul/ymir@0.16.0-dev.20181107(transitive)

• Updated@fimbul/ymir@0.16.0-dev.20181115

• Updatedtsutils@^3.5.0