Add interface-over-type-literal rule

docs/_data/rules.json

@@ -48,9 +48,9 @@
       ]
     },
     "optionExamples": [
-      "[true, array]",
-      "[true, generic]",
-      "[true, array-simple]"
+      "[true, \"array\"]",
+      "[true, \"generic\"]",
+      "[true, \"array-simple\"]"
     ],
     "type": "style",
     "typescriptOnly": true
@@ -269,6 +269,15 @@
     "type": "style",
     "typescriptOnly": true
   },
+  {
+    "ruleName": "interface-over-type-literal",
+    "description": "Prefer an interface declaration over `type T = { ... }`",
+    "rationale": "style",
+    "optionsDescription": "Not configurable.",
+    "options": null,
+    "type": "style",
+    "typescriptOnly": true
+  },
   {
     "ruleName": "jsdoc-format",
     "description": "Enforces basic format rules for JSDoc comments.",
@@ -606,9 +615,6 @@
     "rationale": "An empty interface is equivalent to its supertype (or `{}`).",
     "optionsDescription": "Not configurable.",
     "options": null,
-    "optionExamples": [
-      "true"
-    ],
     "type": "typescript",
     "typescriptOnly": true
   },

docs/rules/array-type/index.html

@@ -31,4 +31,4 @@
       "array-simple"
     ]
   }
----
+---

docs/rules/interface-over-type-literal/index.html

@@ -0,0 +1,12 @@
+---
+ruleName: interface-over-type-literal
+description: 'Prefer an interface declaration over `type T = { ... }`'
+rationale: style
+optionsDescription: Not configurable.
+options: null
+type: style
+typescriptOnly: true
+layout: rule
+title: 'Rule: interface-over-type-literal'
+optionsJSON: 'null'
+---

docs/rules/no-empty-interface/index.html

@@ -4,8 +4,6 @@
 rationale: 'An empty interface is equivalent to its supertype (or `{}`).'
 optionsDescription: Not configurable.
 options: null
-optionExamples:
-  - 'true'
 type: typescript
 typescriptOnly: true
 layout: rule

src/rules/interfaceOverTypeLiteralRule.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as ts from "typescript";
+
+import * as Lint from "../index";
+
+export class Rule extends Lint.Rules.AbstractRule {
+    /* tslint:disable:object-literal-sort-keys */
+    public static metadata: Lint.IRuleMetadata = {
+        ruleName: "interface-over-type-literal",
+        description: "Prefer an interface declaration over a type literal (`type T = { ... }`)",
+        rationale: "style",
+        optionsDescription: "Not configurable.",
+        options: null,
+        type: "style",
+        typescriptOnly: true,
+    };
+    /* tslint:enable:object-literal-sort-keys */
+
+    public static FAILURE_STRING = "Use an interface instead of a type literal.";
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new Walker(sourceFile, this.getOptions()));
+    }
+}
+
+class Walker extends Lint.RuleWalker {
+    public visitTypeAliasDeclaration(node: ts.TypeAliasDeclaration) {
+        if (node.type.kind === ts.SyntaxKind.TypeLiteral) {
+            this.addFailureAtNode(node.name, Rule.FAILURE_STRING);
+        }
+        super.visitTypeAliasDeclaration(node);
+    }
+}

src/rules/noEmptyInterfaceRule.ts

@@ -27,7 +27,6 @@ export class Rule extends Lint.Rules.AbstractRule {
         rationale: "An empty interface is equivalent to its supertype (or `{}`).",
         optionsDescription: "Not configurable.",
         options: null,
-        optionExamples: ["true"],
         type: "typescript",
         typescriptOnly: true,
     };

test/rules/interface-over-type-literal/test.ts.lint

@@ -0,0 +1,5 @@
+type T = { x: number; }
+     ~                  [Use an interface instead of a type literal.]
+
+type U = string;
+type V = { x: number; } | { y: string; };

test/rules/interface-over-type-literal/tslint.json

@@ -0,0 +1,5 @@
+{
+    "rules": {
+        "interface-over-type-literal": true
+    }
+}