Give some love to the linter

Author: dcodeIO

bin/asc.js

@@ -534,7 +534,7 @@ exports.main = function main(argv, options, callback) {
 
   function readFileNode(filename) {
     try {
-      var text;
+      let text;
       stats.readCount++;
       stats.readTime += measure(() => {
         text = fs.readFileSync(filename, { encoding: "utf8" });

dist/asc.js

@@ -0,0 +1,41 @@
+![AS](https://avatars1.githubusercontent.com/u/28916798?s=48) lint
+======================
+
+Recommended [TSLint](https://github.com/palantir/tslint) rules for use with AssemblyScript. Meant to spot the most common issues as you type.
+
+Not a sophisticated checker in its current state.
+
+Usage
+-----
+
+Add the following `tslint.json` to your project:
+
+```json
+{
+  "extends": "@assemblyscript/lint"
+}
+```
+
+Add additional rules if necessary.
+
+Add a script to your `package.json`:
+
+```json
+"scripts": {
+  "lint": "tslint -c tslint.json --project ./path/to[/tsconfig.json] --format as"
+}
+```
+
+Now, to check your sources, run:
+
+```
+$> npm run lint
+```
+
+If you are using [Visual Studio Code](https://code.visualstudio.com/), there's also a [TSLint extension](https://marketplace.visualstudio.com/items?itemName=eg2.tslint) that highlights issues as you type.
+
+Custom rules
+------------
+
+* **as-types** checks that all types are annotated or have an initializer.
+* **as-variables** checks the use of `var` and `let` to match their semantic meaning. For reference, `var` becomes a distinct local or mutable global, while `let` becomes a shared local.

dist/asc.js.map

@@ -0,0 +1,118 @@
+{
+  "rules": {
+    "adjacent-overload-signatures": {},
+    "ban-types": {
+      "severity": "error",
+      "options": [
+        ["object", "Not supported."],
+        ["any", "Not supported."],
+        ["undefined", "Not supported."],
+        ["never", "Not supported."],
+        ["number", "Use one of the WebAssembly types instead."],
+        ["boolean", "Use `bool` instead."]
+      ]
+    },
+    "object-literal-shorthand": {
+      "severity": "error",
+      "options": ["never"]
+    },
+    "restrict-plus-operands": {
+      "severity": "error"
+    },
+    "curly": {
+      "options": ["ignore-same-line"]
+    },
+    "deprecation": {},
+    "encoding": {
+      "severity": "error"
+    },
+    "eofline": {},
+    "label-position": {
+      "severity": "error"
+    },
+    "new-parens": {
+      "severity": "error"
+    },
+    "no-any": {
+      "severity": "error"
+    },
+    "no-arg": {
+      "severity": "error"
+    },
+    "no-consecutive-blank-lines": {},
+    "no-debugger": {
+      "severity": "error"
+    },
+    "no-default-export": {
+      "severity": "error"
+    },
+    "no-duplicate-imports": {
+      "severity": "error"
+    },
+    "no-duplicate-super": {
+      "severity": "error"
+    },
+    "no-duplicate-switch-case": {
+      "severity": "error"
+    },
+    "no-duplicate-variable": {
+      "severity": "error"
+    },
+    "no-eval": {
+      "severity": "error"
+    },
+    "no-inferred-empty-object-type": {
+      "severity": "error"
+    },
+    "no-internal-module": {
+      "severity": "error"
+    },
+    "no-invalid-template-strings": {
+      "severity": "error"
+    },
+    "no-invalid-this": {
+      "severity": "error"
+    },
+    "no-irregular-whitespace": {},
+    "no-misused-new": {
+      "severity": "error"
+    },
+    "no-object-literal-type-assertion": {
+      "severity": "error"
+    },
+    "no-parameter-properties": {
+      "severity": "error"
+    },
+    "no-require-imports": {
+      "severity": "error"
+    },
+    "no-shadowed-variable": {},
+    "no-sparse-arrays": {},
+    "no-string-literal": {
+      "severity": "error"
+    },
+    "no-string-throw": {
+      "severity": "error"
+    },
+    "no-trailing-whitespace": {},
+    "no-unbound-method": {
+      "severity": "error"
+    },
+    "no-unsafe-any": {
+      "severity": "error"
+    },
+    "no-unused-variable": {
+      "options": [{
+        "ignore-pattern": "^_"
+      }]
+    },
+    "no-void-expression": {
+      "severity": "error"
+    },
+    "prefer-method-signature": {},
+    "radix": {},
+    "semicolon": {
+      "options": ["always"]
+    }
+  }
+}

dist/assemblyscript.js.map

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractFormatter_1 = require("tslint/lib/language/formatter/abstractFormatter");
+const colorBlue = "\u001b[93m";
+const colorYellow = "\u001b[93m";
+const colorRed = "\u001b[91m";
+const colorReset = "\u001b[0m";
+class Formatter extends abstractFormatter_1.AbstractFormatter {
+    format(failures) {
+        return `${this.mapToMessages(failures).join("\n")}\n`;
+    }
+    mapToMessages(failures) {
+        return failures.map((failure) => {
+            var fileName = failure.getFileName();
+            var failureString = failure.getFailure();
+            var ruleName = failure.getRuleName();
+            var lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
+            var positionTuple = `:${lineAndCharacter.line + 1}:${lineAndCharacter.character + 1}`;
+            if (this.lastSeverity == failure.getRuleSeverity() && this.lastFailure == failureString) {
+                return "  in " + fileName + positionTuple;
+            }
+            else {
+                let message = this.lastSeverity ? "\n" : "";
+                switch (this.lastSeverity = failure.getRuleSeverity()) {
+                    case "warning": {
+                        message += colorYellow + "WARNING:" + colorReset;
+                        break;
+                    }
+                    case "error": {
+                        message += colorRed + "ERROR:" + colorReset;
+                        break;
+                    }
+                    default: {
+                        message += failure.getRuleSeverity();
+                        break;
+                    }
+                }
+                this.lastFailure = failureString;
+                return message + " " + failureString + " [" + ruleName + "]\n  in " + fileName + positionTuple;
+            }
+        });
+    }
+}
+Formatter.metadata = {
+    formatterName: "as",
+    description: "AssemblyScript's TSLint formatter.",
+    sample: "Similar to ASC's output.",
+    consumer: "human",
+};
+exports.Formatter = Formatter;

lib/lint/README.md

@@ -0,0 +1,11 @@
+{
+  "extends": "./base.json",
+  "rulesDirectory": ["./rules", "./rules/internal"],
+  "formattersDirectory": ["./formatters"],
+  "rules": {
+    "as-types": {
+      "severity": "error"
+    },
+    "as-variables": {}
+  }
+}

lib/lint/base.json

@@ -0,0 +1,21 @@
+{
+  "name": "@assemblyscript/lint",
+  "version": "1.0.0",
+  "main": "index.json",
+  "scripts": {
+    "build": "tsc --project ./src --outDir . --diagnostics"
+  },
+  "peerDependencies": {
+    "tslint": "^5.9.1"
+  },
+  "devDependencies": {
+    "typescript": "^2.7.2"
+  },
+  "files": [
+    "index.json",
+    "package.json",
+    "README.md",
+    "rules/",
+    "formatters/"
+  ]
+}

lib/lint/formatters/asFormatter.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts = require("typescript");
+const Lint = require("tslint");
+class Rule extends Lint.Rules.AbstractRule {
+    apply(sourceFile) {
+        return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));
+    }
+}
+Rule.MISSING_TYPE_OR_INITIALIZER = "Missing type or initializer.";
+Rule.MISSING_RETURN_TYPE = "Missing return type.";
+exports.Rule = Rule;
+class DiagnosticsWalker extends Lint.RuleWalker {
+    visitVariableDeclaration(node) {
+        var list = node.parent;
+        if (list) {
+            let stmt = list.parent;
+            if (stmt && stmt.kind != ts.SyntaxKind.ForOfStatement) {
+                this.checkTypeOrInitializer(node);
+            }
+        }
+        super.visitVariableDeclaration(node);
+    }
+    visitPropertyDeclaration(node) {
+        this.checkTypeOrInitializer(node);
+        super.visitPropertyDeclaration(node);
+    }
+    visitParameterDeclaration(node) {
+        this.checkTypeOrInitializer(node);
+        super.visitParameterDeclaration(node);
+    }
+    checkTypeOrInitializer(node) {
+        if (!node.type && !node.initializer) {
+            this.addFailureAtNode(node, Rule.MISSING_TYPE_OR_INITIALIZER);
+        }
+    }
+    visitFunctionDeclaration(node) {
+        this.checkFunctionReturnType(node);
+        super.visitFunctionDeclaration(node);
+    }
+    visitArrowFunction(node) {
+        this.checkFunctionReturnType(node);
+        super.visitArrowFunction(node);
+    }
+    visitMethodDeclaration(node) {
+        this.checkFunctionReturnType(node);
+        super.visitMethodDeclaration(node);
+    }
+    visitGetAccessor(node) {
+        this.checkFunctionReturnType(node);
+        super.visitGetAccessor(node);
+    }
+    checkFunctionReturnType(node) {
+        if (!node.type) {
+            this.addFailureAtNode(node, Rule.MISSING_RETURN_TYPE);
+        }
+    }
+}