feat(no-ignored-subscribe): Add rule.

fixtures/subscription-with-arguments/fixture.ts

@@ -0,0 +1,4 @@
+import { of } from "rxjs/Observable/of";
+
+const observable = of([1, 2]);
+observable.subscribe(value => console.log(value));

fixtures/subscription-with-arguments/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "lib": ["es2015"],
+    "noEmit": true,
+    "paths": {
+      "rxjs": ["../node_modules/rxjs"]
+    },
+    "skipLibCheck": true,
+    "target": "es5"
+  },
+  "include": ["fixture.ts"]
+}

fixtures/subscription-with-arguments/tslint.json

@@ -0,0 +1,10 @@
+{
+  "defaultSeverity": "error",
+  "jsRules": {},
+  "rules": {
+    "rxjs-no-ignored-subscribe": {
+      "severity": "error"
+    }
+  },
+  "rulesDirectory": "../../build/rules"
+}

fixtures/subscription-without-arguments/fixture.ts

@@ -0,0 +1,4 @@
+import { of } from "rxjs/Observable/of";
+
+const observable = of([1, 2]);
+observable.subscribe();

fixtures/subscription-without-arguments/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "lib": ["es2015"],
+    "noEmit": true,
+    "paths": {
+      "rxjs": ["../node_modules/rxjs"]
+    },
+    "skipLibCheck": true,
+    "target": "es5"
+  },
+  "include": ["fixture.ts"]
+}

fixtures/subscription-without-arguments/tslint.json

@@ -0,0 +1,10 @@
+{
+  "defaultSeverity": "error",
+  "jsRules": {},
+  "rules": {
+    "rxjs-no-ignored-subscribe": {
+      "severity": "error"
+    }
+  },
+  "rulesDirectory": "../../build/rules"
+}

source/fixtures-spec.ts

@@ -482,33 +482,58 @@ describe("fixtures", function (): void {
     });
 
     describe("subscription related rules", () => {
+
         describe("subscription-without-error-handler", () => {
+
             it("should effect an 'rxjs-no-ignored-error' error on Observable", () => {
                 const result = lint("subscription-without-error-handler", "tslint.json", "fixture-observable.ts");
                 expect(result).to.have.property("errorCount", 1);
                 expect(result.failures[0]).to.have.property("ruleName", "rxjs-no-ignored-error");
             });
         });
+
         describe("subscription-without-error-handler", () => {
+
             it("should effect an 'rxjs-no-ignored-error' error on Observable's ancestors", () => {
                 const result = lint("subscription-without-error-handler", "tslint.json", "fixture-subject.ts");
                 expect(result).to.have.property("errorCount", 1);
                 expect(result.failures[0]).to.have.property("ruleName", "rxjs-no-ignored-error");
             });
         });
+
         describe("subscription-without-error-handler", () => {
+
             it("should effect an 'rxjs-no-ignored-error' error even if first parameter is a funciton variable", () => {
                 const result = lint("subscription-without-error-handler", "tslint.json", "fixture-with-parameter.ts");
                 expect(result).to.have.property("errorCount", 1);
                 expect(result.failures[0]).to.have.property("ruleName", "rxjs-no-ignored-error");
             });
         });
+
         describe("subscription-with-error-handler", () => {
+
             it("should not produce errors", () => {
                 const result = lint("subscription-with-error-handler", "tslint.json");
                 expect(result).to.have.property("errorCount", 0);
             });
         });
+
+        describe("subscription-with-arguments", () => {
+
+            it("should not effect an error", () => {
+                const result = lint("subscription-with-arguments", "tslint.json");
+                expect(result).to.have.property("errorCount", 0);
+            });
+        });
+
+        describe("subscription-without-arguments", () => {
+
+            it("should effect an 'rxjs-no-ignored-subscribe' error", () => {
+                const result = lint("subscription-without-arguments", "tslint.json");
+                expect(result).to.have.property("errorCount", 1);
+                expect(result.failures[0]).to.have.property("ruleName", "rxjs-no-ignored-subscribe");
+            });
+        });
     });
 
     function lint(dir: string, configFileName?: string, fixtureFileName?: string): LintResult {

source/rules/rxjsNoIgnoredSubscribeRule.ts

@@ -0,0 +1,57 @@
+/**
+ * @license Use of this source code is governed by an MIT-style license that
+ * can be found in the LICENSE file at https://github.com/cartant/rxjs-tslint-rules
+ */
+/*tslint:disable:no-use-before-declare*/
+
+import * as Lint from "tslint";
+import * as ts from "typescript";
+
+import { couldBeType, isReferenceType } from "../support/util";
+
+export class Rule extends Lint.Rules.TypedRule {
+
+    public static metadata: Lint.IRuleMetadata = {
+        description: "Disallows the calling of subscribe without specifying arguments.",
+        options: null,
+        optionsDescription: "Not configurable.",
+        requiresTypeInfo: true,
+        ruleName: "rxjs-no-ignored-subscribe",
+        type: "functionality",
+        typescriptOnly: true
+    };
+
+    public static FAILURE_STRING = "Calling subscribe without arguments is forbidden";
+
+    public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
+
+        return this.applyWithWalker(new Walker(sourceFile, this.getOptions(), program));
+    }
+}
+
+export class Walker extends Lint.ProgramAwareRuleWalker {
+
+    protected visitCallExpression(node: ts.CallExpression): void {
+
+        node.forEachChild((child) => {
+
+            if (child.kind === ts.SyntaxKind.PropertyAccessExpression) {
+
+                const propertyAccessExpression = child as ts.PropertyAccessExpression;
+                const name = propertyAccessExpression.name.getText();
+                const typeChecker = this.getTypeChecker();
+                const type = typeChecker.getTypeAtLocation(propertyAccessExpression.expression);
+
+                if ((name === "subscribe") &&
+                    isReferenceType(type) &&
+                    couldBeType(type.target, "Observable") &&
+                    (node.arguments.length === 0)
+                ) {
+                    this.addFailureAtNode(propertyAccessExpression.name, Rule.FAILURE_STRING);
+                }
+            }
+        });
+
+        super.visitCallExpression(node);
+    }
+}