New rule: no-ignore-return-values

config/rulesets/solium-all.js

@@ -36,6 +36,7 @@ module.exports = {
         "emit": "warning",
         "no-constant": "warning",
         "no-experimental": "warning",
+        "no-ignore-return-value": "warning",
         "max-len": "warning",
         "error-reason": "warning",
         "visibility-first": "warning",

config/rulesets/solium-recommended.js

@@ -31,6 +31,7 @@ module.exports = {
         "error-reason": "warning",
         "constructor": "warning",
         "visibility-first": "warning",
+        "no-ignore-return-value": "warning",
 
         "lbrace": "off",
         "mixedcase": "off",
@@ -39,8 +40,8 @@ module.exports = {
         "blank-lines": "off",
         "arg-overflow": "off",
         "function-order": "off",
-        "conditionals-whitespace": "off",
         "no-experimental": "off",
+        "conditionals-whitespace": "off",
 
         // Disable deprecated rules
         "double-quotes": "off",

config/solium.json

@@ -134,6 +134,13 @@
 			"description": "Ensure that experimental features are not used in production"
 		},
 
+		"no-ignore-return-value": {
+			"enabled": true,
+			"recommended": true,
+			"type": "warning",
+			"description": "Ensure that the return value of a function call is not ignored"
+		},
+
 		"blank-lines": {
 			"enabled": true,
 			"recommended": true,

lib/rules/no-ignore-return-value.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Ensure that the return value of a function call is not ignored
+ * @author Yuichi Nukiyama
+ */
+
+"use strict";
+
+module.exports = {
+
+    meta: {
+
+        docs: {
+            recommended: true,
+            type: "warning",
+            description: "Ensure that the return value of a function call is not ignored"
+        },
+
+        schema: []
+
+    },
+
+    create: function(context) {
+
+        const sourceCode = context.getSourceCode();
+        const calleeIgnoreReturnParams = [];
+        const namesOfFunctionWithReturnParams = [];
+
+        function inspectFunctionDeclaration(emitted) {
+            const node = emitted.node;
+
+            if (emitted.exit) {
+                return;
+            }
+
+            if (node.returnParams !== null) {
+                namesOfFunctionWithReturnParams.push(node.name);
+            }
+        }
+
+        function inspectCallExpression(emitted) {
+            const node = emitted.node;
+
+            if (emitted.exit) {
+                return;
+            }
+
+            // check callee without assignment
+            if (sourceCode.getParent(node).type !== "AssignmentExpression") {
+                calleeIgnoreReturnParams.push(node);
+            }
+        }
+
+        function inspectProgram(emitted) {
+            if (emitted.exit) {
+                const errorNodes = calleeIgnoreReturnParams.filter(node => {
+                    for (const name of namesOfFunctionWithReturnParams) {
+                        if (name === node.callee.name) {
+                            return true;
+                        }
+                    }                   
+
+                });
+
+                errorNodes.forEach(node => {
+                    context.report({
+                        node: node,
+                        message: node.callee.name + "don't use return values." 
+                    });
+                });
+            }  
+        }
+
+        return {
+            CallExpression: inspectCallExpression,
+            FunctionDeclaration:inspectFunctionDeclaration,
+            Program: inspectProgram
+        };
+    }
+};

test/lib/rules.js

@@ -212,7 +212,7 @@ describe("Checking exported rules object", function() {
         // We extend ALL solium core rules and eliminate a few by setting their severity to 0.
         // The rest of the rules should all be available.
         // The below count will keep changing with every change in the number of core rules that exist in solium.
-        Object.keys(ruleDescriptions).length.should.equal(29);
+        Object.keys(ruleDescriptions).length.should.equal(30);
 
         done();
     });

test/lib/rules/no-ignore-return-value/no-ignore-return-value.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Tests for no-ignore-return-value rule
+ * @author Yuichi Nukiyama
+ */
+
+"use strict";
+
+const Solium = require("../../../../lib/solium");
+const userConfig = {
+    "rules": {
+        "no-ignore-return-value": "warning"
+    }
+};
+
+
+describe("[RULE] no-ignore-return-value: Acceptances", function() {
+
+    it("should accept functions which use return value", done => {
+        let codes = [`
+			contract Foo {
+				function a(uint x) private returns (uint) { return 1; }
+				function b() private { uint c = a(1); }
+			}
+        `];
+
+        codes.push(`
+            contract Foo {
+                uint c;
+                function a(uint x) private returns (uint) {}
+                function b() private { c = a(1); }
+            }
+        `);
+
+        codes.push(`
+            contract Foo {
+                function a(uint x) public {}
+                function b() private { a(1); }
+            }
+        `);
+
+        codes.forEach(code => {
+            const errors = Solium.lint(code, userConfig);
+            errors.should.be.Array();
+            errors.should.have.size(0);
+        });
+
+        Solium.reset();
+        done();
+    });
+});
+
+describe("[RULE] no-ignore-return-value: Rejections", function() {
+
+    it("should reject functions which don't use return value", done => {
+        let codes = [`
+			contract Foo {
+				function a(uint x) private returns (uint) { return 1; }
+				function b() private { a(1); }
+			}
+        `];
+
+        codes.push(`
+            contract Foo {
+                uint c;
+                function a() private returns (uint) {}
+                function b() private { a(); }
+            }
+        `);
+
+        codes.forEach(code => {
+            const errors = Solium.lint(code, userConfig);
+            errors.should.be.Array();
+            errors.should.have.size(1);
+        });
+
+        Solium.reset();
+        done();
+    });
+});