3 files changed, 97 insertions, 0 deletions
diff --git a/packages/tslint-config/rules/asyncSuffixRule.ts b/packages/tslint-config/rules/asyncSuffixRule.ts
new file mode 100644
index 000000000..5215c7151
--- /dev/null
+++ b/packages/tslint-config/rules/asyncSuffixRule.ts
@@ -0,0 +1,10 @@
+import * as Lint from 'tslint';
+import * as ts from 'typescript';
+
+import { AsyncSuffixWalker } from './walkers/async_suffix';
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new AsyncSuffixWalker(sourceFile, this.getOptions()));
+    }
+}
diff --git a/packages/tslint-config/rules/underscorePrivatesRule.ts b/packages/tslint-config/rules/underscorePrivatesRule.ts
new file mode 100644
index 000000000..472ea09ff
--- /dev/null
+++ b/packages/tslint-config/rules/underscorePrivatesRule.ts
@@ -0,0 +1,61 @@
+import * as Lint from 'tslint';
+import * as ts from 'typescript';
+
+const UNDERSCORE = '_';
+
+type RelevantClassMember =
+    | ts.MethodDeclaration
+    | ts.PropertyDeclaration
+    | ts.GetAccessorDeclaration
+    | ts.SetAccessorDeclaration;
+
+// Copied from: https://github.com/DanielRosenwasser/underscore-privates-tslint-rule
+// The version on github is not published on npm
+export class Rule extends Lint.Rules.AbstractRule {
+    public static FAILURE_STRING = 'private members must be prefixed with an underscore';
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithFunction(sourceFile, walk);
+    }
+}
+function walk(ctx: Lint.WalkContext<void>): void {
+    traverse(ctx.sourceFile);
+
+    function traverse(node: ts.Node): void {
+        checkNodeForViolations(ctx, node);
+        return ts.forEachChild(node, traverse);
+    }
+}
+function checkNodeForViolations(ctx: Lint.WalkContext<void>, node: ts.Node): void {
+    if (!isRelevantClassMember(node)) {
+        return;
+    }
+    // The declaration might have a computed property name or a numeric name.
+    const name = node.name;
+    if (!nameIsIdentifier(name)) {
+        return;
+    }
+    if (!nameStartsWithUnderscore(name.text) && memberIsPrivate(node)) {
+        ctx.addFailureAtNode(name, Rule.FAILURE_STRING);
+    }
+}
+function isRelevantClassMember(node: ts.Node): node is RelevantClassMember {
+    switch (node.kind) {
+        case ts.SyntaxKind.MethodDeclaration:
+        case ts.SyntaxKind.PropertyDeclaration:
+        case ts.SyntaxKind.GetAccessor:
+        case ts.SyntaxKind.SetAccessor:
+            return true;
+        default:
+            return false;
+    }
+}
+function nameStartsWithUnderscore(text: string) {
+    return text.charCodeAt(0) === UNDERSCORE.charCodeAt(0);
+}
+function memberIsPrivate(node: ts.Declaration) {
+    return Lint.hasModifier(node.modifiers, ts.SyntaxKind.PrivateKeyword);
+}
+function nameIsIdentifier(node: ts.Node): node is ts.Identifier {
+    return node.kind === ts.SyntaxKind.Identifier;
+}
diff --git a/packages/tslint-config/rules/walkers/async_suffix.ts b/packages/tslint-config/rules/walkers/async_suffix.ts
new file mode 100644
index 000000000..eaec9c5f6
--- /dev/null
+++ b/packages/tslint-config/rules/walkers/async_suffix.ts
@@ -0,0 +1,26 @@
+import * as _ from 'lodash';
+import * as Lint from 'tslint';
+import * as ts from 'typescript';
+
+export class AsyncSuffixWalker extends Lint.RuleWalker {
+    public static FAILURE_STRING = 'async functions must have an Async suffix';
+    public visitMethodDeclaration(node: ts.MethodDeclaration): void {
+        const methodNameNode = node.name;
+        const methodName = methodNameNode.getText();
+        if (!_.isUndefined(node.type)) {
+            if (node.type.kind === ts.SyntaxKind.TypeReference) {
+                // tslint:disable-next-line:no-unnecessary-type-assertion
+                const returnTypeName = (node.type as ts.TypeReferenceNode).typeName.getText();
+                if (returnTypeName === 'Promise' && !methodName.endsWith('Async')) {
+                    const failure = this.createFailure(
+                        methodNameNode.getStart(),
+                        methodNameNode.getWidth(),
+                        AsyncSuffixWalker.FAILURE_STRING,
+                    );
+                    this.addFailure(failure);
+                }
+            }
+        }
+        super.visitMethodDeclaration(node);
+    }
+}