Coverage (#237)

* try/catch had a bug and all the coverage is taking care of all cases

* UsingForDeclaration now has 100% coverage

* Labels have coverage now

* small refactor for UsingForDeclaration

* removing TupleExpression hack

* last details for coverage

Author: Janther

src/nodes/CatchClause.js

@@ -6,15 +6,22 @@ const {
 
 const printList = require('./print-list');
 
+const parameters = (node, path, print) =>
+  node.parameters
+    ? concat([
+        node.isReasonStringType ? 'Error' : '',
+        '(',
+        printList(path.map(print, 'parameters')),
+        ') '
+      ])
+    : '';
+
 const CatchClause = {
   print: ({ node, path, print }) => {
     return group(
       concat([
         'catch ',
-        node.isReasonStringType ? 'Error' : '',
-        '(',
-        printList(path.map(print, 'parameters')),
-        ') ',
+        parameters(node, path, print),
         path.call(print, 'body')
       ])
     );

src/nodes/LabelDefinition.js

@@ -1,11 +1,11 @@
 const {
   doc: {
-    builders: { concat, line }
+    builders: { concat, dedent, line }
   }
 } = require('prettier/standalone');
 
 const LabelDefinition = {
-  print: ({ node }) => concat([node.name, ':', line])
+  print: ({ node }) => concat([dedent(line), node.name, ':'])
 };
 
 module.exports = LabelDefinition;

src/nodes/StateVariableDeclaration.js

@@ -4,21 +4,16 @@ const {
   }
 } = require('prettier/standalone');
 
+const initialValue = (node, path, print) =>
+  node.initialValue ? concat([' = ', path.call(print, 'initialValue')]) : '';
+
 const StateVariableDeclaration = {
-  print: ({ node, path, print }) => {
-    let doc = concat(
-      path.map(statementPath => {
-        if (!statementPath.getValue()) {
-          return ', ';
-        }
-        return print(statementPath);
-      }, 'variables')
-    );
-    if (node.initialValue) {
-      doc = concat([doc, ' = ', path.call(print, 'initialValue')]);
-    }
-    return concat([doc, ';']);
-  }
+  print: ({ node, path, print }) =>
+    concat([
+      ...path.map(print, 'variables'),
+      initialValue(node, path, print),
+      ';'
+    ])
 };
 
 module.exports = StateVariableDeclaration;

src/nodes/TupleExpression.js

@@ -11,10 +11,9 @@ const contents = (node, path, print) =>
   node.components.length === 1 &&
   node.components[0].type === 'BinaryOperation'
     ? path.map(print, 'components')
-    : [printList(path.map(print, node.components ? 'components' : 'elements'))];
+    : [printList(path.map(print, 'components'))];
 
 const TupleExpression = {
-  // @TODO: remove hack once solidity-parser-antlr is fixed
   print: ({ node, path, print }) =>
     group(
       concat([

src/nodes/UsingForDeclaration.js

@@ -5,18 +5,14 @@ const {
 } = require('prettier/standalone');
 
 const UsingForDeclaration = {
-  print: ({ node, path, print }) => {
-    if (node.typeName) {
-      return concat([
-        'using ',
-        node.libraryName,
-        ' for ',
-        path.call(print, 'typeName'),
-        ';'
-      ]);
-    }
-    return concat(['using ', node.libraryName, ' for *;']);
-  }
+  print: ({ node, path, print }) =>
+    concat([
+      'using ',
+      node.libraryName,
+      ' for ',
+      node.typeName ? path.call(print, 'typeName') : '*',
+      ';'
+    ])
 };
 
 module.exports = UsingForDeclaration;

src/parser.js

@@ -21,9 +21,7 @@ function parse(text, parsers, options) {
       if (ctx.initExpression) {
         ctx.initExpression.omitSemicolon = true;
       }
-      if (ctx.loopExpression) {
-        ctx.loopExpression.omitSemicolon = true;
-      }
+      ctx.loopExpression.omitSemicolon = true;
     },
     HexLiteral(ctx) {
       ctx.value = options.singleQuote

tests/AllSolidityFeatures/AllSolidityFeatures.sol

@@ -259,6 +259,7 @@ library UsingExampleLibrary {
 }
 
 contract UsingExampleContract {
+  using UsingExampleLibrary for *;
   using UsingExampleLibrary for uint[];
 }
 

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

@@ -262,6 +262,7 @@ library UsingExampleLibrary {
 }
 
 contract UsingExampleContract {
+  using UsingExampleLibrary for *;
   using UsingExampleLibrary for uint[];
 }
 
@@ -723,6 +724,7 @@ library UsingExampleLibrary {
 
 
 contract UsingExampleContract {
+    using UsingExampleLibrary for *;
     using UsingExampleLibrary for uint256[];
 }
 

tests/Assembly/Assembly.sol

@@ -100,4 +100,36 @@ for { let i := 0 } lt(i, x) { i := add(i, 1) } { y := mul(2, y) }
   			}
     		}
     }
+
+  function assemblyLabels() {
+  assembly {
+    let n := calldataload(4)
+    let a := 1
+    let b := a
+loop:
+    jumpi(loopend, eq(n, 0))
+    a add swap1
+    n := sub(n, 1)
+    jump(loop)
+loopend:
+    mstore(0, a)
+    return(0, 0x20)
+}
+
+assembly{
+    let x := 8
+    jump(two)
+    one:
+        // Here the stack height is 2 (because we pushed x and 7),
+        // but the assembler thinks it is 1 because it reads
+        // from top to bottom.
+        // Accessing the stack variable x here will lead to errors.
+        x := 9
+        jump(three)
+    two:
+        7 // push something onto the stack
+        jump(one)
+    three:
+}
+}
 }

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

@@ -103,6 +103,38 @@ for { let i := 0 } lt(i, x) { i := add(i, 1) } { y := mul(2, y) }
   			}
     		}
     }
+
+  function assemblyLabels() {
+  assembly {
+    let n := calldataload(4)
+    let a := 1
+    let b := a
+loop:
+    jumpi(loopend, eq(n, 0))
+    a add swap1
+    n := sub(n, 1)
+    jump(loop)
+loopend:
+    mstore(0, a)
+    return(0, 0x20)
+}
+
+assembly{
+    let x := 8
+    jump(two)
+    one:
+        // Here the stack height is 2 (because we pushed x and 7),
+        // but the assembler thinks it is 1 because it reads
+        // from top to bottom.
+        // Accessing the stack variable x here will lead to errors.
+        x := 9
+        jump(three)
+    two:
+        7 // push something onto the stack
+        jump(one)
+    three:
+}
+}
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 contract Assembly {
@@ -236,6 +268,45 @@ contract Assembly {
             }
         }
     }
+
+    function assemblyLabels() {
+        assembly {
+            let n := calldataload(4)
+            let a := 1
+            let b := a
+
+        loop:
+            jumpi(loopend, eq(n, 0))
+            a
+            add
+            swap1
+            n := sub(n, 1)
+            jump(loop)
+
+        loopend:
+            mstore(0, a)
+            return(0, 0x20)
+        }
+
+        assembly {
+            let x := 8
+            jump(two)
+
+        one:
+            // Here the stack height is 2 (because we pushed x and 7),
+            // but the assembler thinks it is 1 because it reads
+            // from top to bottom.
+            // Accessing the stack variable x here will lead to errors.
+            x := 9
+            jump(three)
+
+        two:
+            7 // push something onto the stack
+            jump(one)
+
+        three:
+        }
+    }
 }
 
 `;