Adding spaces between functions and contracts (#217)

* Removing extra empty lines at the end of a block

* Adding spaces between functions and contracts

* adding scenario where function is followed by a non-function node

Author: Janther

src/nodes/print-preserving-empty-lines.js

@@ -8,21 +8,46 @@ const {
 function printPreservingEmptyLines(path, key, options, print) {
   const parts = [];
   path.each(childPath => {
+    const node = childPath.getValue();
+    const nodeType = node.type;
+
     if (parts.length !== 0) {
       parts.push(hardline);
     }
 
+    if (childPath.getName() > 0) {
+      if (nodeType === 'ContractDefinition') {
+        if (parts[parts.length - 2] !== hardline) {
+          parts.push(hardline);
+        }
+        parts.push(hardline);
+      }
+
+      if (
+        nodeType === 'FunctionDefinition' &&
+        parts[parts.length - 2] !== hardline
+      ) {
+        parts.push(hardline);
+      }
+    }
+
     parts.push(print(childPath));
+
     if (
       isNextLineEmptyAfterIndex(
         options.originalText,
-        options.locEnd(childPath.getValue()) + 1
-      )
+        options.locEnd(node) + 1
+      ) ||
+      nodeType === 'FunctionDefinition'
     ) {
       parts.push(hardline);
     }
   }, key);
 
+  if (parts.length > 1 && parts[parts.length - 1] === hardline) {
+    parts.pop();
+  }
+
   return concat(parts);
 }
 

tests/AddressPayable/__snapshots__/jsfmt.spec.js.snap

@@ -13,8 +13,10 @@ contract AddressPayable {
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 pragma solidity ^0.5.2;
 
+
 contract AddressPayable {
     address payable[] hello;
+
     function sendSomeEth(address payable to, address payable[] memory world)
         public
         payable

tests/AllSolidityFeatures/__snapshots__/jsfmt.spec.js.snap

@@ -426,45 +426,56 @@ import "SomeFile.sol" as SomeOtherFile;
 import "AnotherFile.sol" as SomeSymbol;
 import {symbol1 as alias, symbol2} from "File.sol";
 
+
 interface i {
     function f();
 }
 
+
 contract c {
     function c() {
         val1 = 1 wei; // 1
         val2 = 1 szabo; // 1 * 10 ** 12
         val3 = 1 finney; // 1 * 10 ** 15
         val4 = 1 ether; // 1 * 10 ** 18
     }
+
     uint256 val1;
     uint256 val2;
     uint256 val3;
     uint256 val4;
 }
 
+
 contract test {
     enum ActionChoices {GoLeft, GoRight, GoStraight, SitStill}
 
     function test() {
         choices = ActionChoices.GoStraight;
     }
+
     function getChoice() returns (uint256 d) {
         d = uint256(choices);
     }
+
     ActionChoices choices;
 }
 
+
 contract Base {
     function Base(uint256 i) {
         m_i = i;
     }
+
     uint256 public m_i;
 }
+
+
 contract Derived is Base(0) {
     function Derived(uint256 i) Base(i) {}
 }
 
+
 contract C {
     uint248 x; // 31 bytes: slot 0, offset 0
     uint16 y; // 2 bytes: slot 1, offset 0 (does not fit in slot 0)
@@ -480,6 +491,7 @@ contract C {
     uint8 gamma; // 1 byte, slot 7 (start new slot after array)
 }
 
+
 contract test {
     function f(uint256 x, uint256 y) returns (uint256 z) {
         var c = x + 3;
@@ -488,36 +500,44 @@ contract test {
     }
 }
 
+
 contract test {
     function f(uint256 x, uint256 y) returns (uint256 z) {
         return 10;
     }
 }
 
+
 contract c {
     function() returns (uint256) {
         return g(8);
     }
+
     function g(uint256 pos) internal returns (uint256) {
         setData(pos, 8);
         return getData(pos);
     }
+
     function setData(uint256 pos, uint256 value) internal {
         data[pos] = value;
     }
+
     function getData(uint256 pos) internal {
         return data[pos];
     }
+
     mapping(uint256 => uint256) data;
 }
 
+
 contract Sharer {
     function sendHalf(address addr) returns (uint256 balance) {
         if (!addr.send(msg.value / 2)) throw; // also reverts the transfer to Sharer
         return address(this).balance;
     }
 }
 
+
 /// @dev Models a modifiable and iterable set of uint values.
 library IntegerSet {
     struct data {
@@ -528,6 +548,7 @@ library IntegerSet {
         /// Number of stored items.
         uint256 size;
     }
+
     function insert(data storage self, uint256 value)
         returns (bool alreadyPresent)
     {
@@ -542,22 +563,27 @@ library IntegerSet {
             return false;
         }
     }
+
     function remove(data storage self, uint256 value) returns (bool success) {
         uint256 index = self.index[value];
         if (index == 0) return false;
         delete self.index[value];
         delete self.items[index];
         self.size--;
     }
+
     function contains(data storage self, uint256 value) returns (bool) {
         return self.index[value] > 0;
     }
+
     function iterate_start(data storage self) returns (uint256 index) {
         return iterate_advance(self, 0);
     }
+
     function iterate_valid(data storage self, uint256 index) returns (bool) {
         return index < self.items.length;
     }
+
     function iterate_advance(data storage self, uint256 index)
         returns (uint256 r_index)
     {
@@ -567,24 +593,28 @@ library IntegerSet {
         ) index++;
         return index;
     }
+
     function iterate_get(data storage self, uint256 index)
         returns (uint256 value)
     {
         return self.items[index];
     }
 }
 
+
 /// How to use it:
 contract User {
     /// Just a struct holding our data.
     IntegerSet.data data;
+
     /// Insert something
     function insert(uint256 v) returns (uint256 size) {
         /// Sends \`data\` via reference, so IntegerSet can modify it.
         IntegerSet.insert(data, v);
         /// We can access members of the struct - but we should take care not to mess with them.
         return data.size;
     }
+
     /// Computes the sum of all stored data.
     function sum() returns (uint256 s) {
         for (
@@ -595,6 +625,7 @@ contract User {
     }
 }
 
+
 // This broke it at one point (namely the modifiers).
 contract DualIndex {
     mapping(uint256 => mapping(uint256 => uint256)) data;
@@ -622,20 +653,26 @@ contract DualIndex {
     }
 }
 
+
 contract A {}
 
+
 contract B {}
 
+
 contract C is A, B {}
 
+
 contract TestPrivate {
     uint256 private value;
 }
 
+
 contract TestInternal {
     uint256 internal value;
 }
 
+
 contract FromSolparse is A, B, TestPrivate, TestInternal {
     function() {
         uint256 a = 6**9;
@@ -644,6 +681,7 @@ contract FromSolparse is A, B, TestPrivate, TestInternal {
     }
 }
 
+
 contract CommentedOutFunction {
     // FYI: This empty function, as well as the commented
     // out function below (bad code) is important to this test.
@@ -652,24 +690,27 @@ contract CommentedOutFunction {
     // function something()
     //  uint x = 10;
     // }
-
 }
 
+
 library VarHasBrackets {
     string constant specialRight = "}";
     //string storage specialLeft = "{";
 }
 
+
 library UsingExampleLibrary {
     function sum(uint256[] storage self) returns (uint256 s) {
         for (uint256 i = 0; i < self.length; i++) s += self[i];
     }
 }
 
+
 contract UsingExampleContract {
     using UsingExampleLibrary for uint256[];
 }
 
+
 contract NewStuff {
     uint256[] b;
 
@@ -679,11 +720,13 @@ contract NewStuff {
     }
 }
 
+
 // modifier with expression
 contract MyContract {
     function fun() mymodifier(foo.bar()) {}
 }
 
+
 library GetCode {
     function at(address _addr) returns (bytes o_code) {
         assembly {
@@ -705,6 +748,7 @@ library GetCode {
     }
 }
 
+
 contract assemblyLocalBinding {
     function test() {
         assembly {
@@ -716,6 +760,7 @@ contract assemblyLocalBinding {
     }
 }
 
+
 contract assemblyReturn {
     uint256 a = 10;
 
@@ -729,10 +774,12 @@ contract assemblyReturn {
     }
 }
 
+
 contract usesConst {
     uint256 const = 0;
 }
 
+
 contract memoryArrays {
     uint256 seven = 7;
 
@@ -746,6 +793,7 @@ contract memoryArrays {
     }
 }
 
+
 contract DeclarativeExpressions {
     uint256 a;
     uint256 b = 7;
@@ -767,6 +815,7 @@ contract DeclarativeExpressions {
     }
 }
 
+
 contract VariableDeclarationTuple {
     function getMyTuple() returns (bool, bool) {
         return (true, false);
@@ -783,11 +832,13 @@ contract VariableDeclarationTuple {
     }
 }
 
+
 contract TypeIndexSpacing {
     uint256[7] x;
     uint256[] y;
 }
 
+
 contract Ballot {
     struct Voter {
         uint256 weight;
@@ -803,6 +854,7 @@ contract Ballot {
         owner(myPrice)
         returns (uint256[], address myAdd, string[] names)
     {}
+
     function foobar()
         payable
         owner(myPrice)
@@ -815,6 +867,7 @@ contract Ballot {
     Voter airbnb = Voter({weight: 2, voted: true});
 }
 
+
 contract multilineReturn {
     function a() returns (uint256 x) {
         return 5;