Merge remote-tracking branch 'origin/main' into slang

# Conflicts:
#	package-lock.json
#	package.json

Author: Janther

src/nodes/ExpressionStatement.js

@@ -1,6 +1,27 @@
+import { doc } from 'prettier';
+import { printComments } from '../common/printer-helpers.js';
+
+const { hardline } = doc.builders;
+
 export const ExpressionStatement = {
-  print: ({ node, path, print }) => [
-    path.call(print, 'expression'),
-    node.omitSemicolon ? '' : ';'
-  ]
+  print: ({ node, options, path, print }) => {
+    const parts = [];
+
+    const parent = path.getParentNode();
+
+    if (parent.type === 'IfStatement') {
+      if (node.comments?.length) {
+        const comments = printComments(node, path, options);
+        if (comments?.length) {
+          parts.push(comments);
+          parts.push(hardline);
+        }
+      }
+    }
+
+    parts.push(path.call(print, 'expression'));
+    parts.push(node.omitSemicolon ? '' : ';');
+
+    return parts;
+  }
 };

src/nodes/IfStatement.js

@@ -1,5 +1,8 @@
 import { doc } from 'prettier';
-import { printSeparatedItem } from '../common/printer-helpers.js';
+import {
+  printComments,
+  printSeparatedItem
+} from '../common/printer-helpers.js';
 
 const { group, hardline, indent, line } = doc.builders;
 
@@ -19,9 +22,10 @@ const printFalseBody = (node, path, print) =>
     ? [' ', path.call(print, 'falseBody')]
     : group(indent([line, path.call(print, 'falseBody')]));
 
-const printElse = (node, path, print) => {
+const printElse = (node, path, print, commentsBetweenIfAndElse) => {
   if (node.falseBody) {
-    const elseOnSameLine = node.trueBody.type === 'Block';
+    const elseOnSameLine =
+      node.trueBody.type === 'Block' && commentsBetweenIfAndElse.length === 0;
     return [
       elseOnSameLine ? ' ' : hardline,
       'else',
@@ -32,11 +36,22 @@ const printElse = (node, path, print) => {
 };
 
 export const IfStatement = {
-  print: ({ node, path, print }) => [
-    'if (',
-    printSeparatedItem(path.call(print, 'condition')),
-    ')',
-    printTrueBody(node, path, print),
-    printElse(node, path, print)
-  ]
+  print: ({ node, options, path, print }) => {
+    const comments = node.comments || [];
+    const commentsBetweenIfAndElse = comments.filter(
+      (comment) => !comment.leading && !comment.trailing
+    );
+
+    const parts = [];
+
+    parts.push('if (', printSeparatedItem(path.call(print, 'condition')), ')');
+    parts.push(printTrueBody(node, path, print));
+    if (commentsBetweenIfAndElse.length && node.falseBody) {
+      parts.push(hardline);
+      parts.push(printComments(node, path, options));
+    }
+    parts.push(printElse(node, path, print, commentsBetweenIfAndElse));
+
+    return parts;
+  }
 };

src/prettier-comments/language-js/comments.js

@@ -257,51 +257,21 @@ function handleIfStatementComments(
     precedingNode === enclosingNode.trueBody &&
     followingNode === enclosingNode.falseBody
   ) {
-    if (followingNode.type === "Block") {
-      if(followingNode.statements.length === 0) {
-        addDanglingComment(followingNode, comment);
-      } else {
-        addLeadingComment(followingNode.statements[followingNode.statements.length - 1], comment);
-      }
-    } else if (followingNode.type === "IfStatement") {
-      if (followingNode.trueBody.type === "Block") {
-        if(followingNode.trueBody.statements.length === 0) {
-          addDanglingComment(followingNode.trueBody, comment);
-        } else {
-          addLeadingComment(followingNode.trueBody.statements[0], comment);
-        }
-      } else {
-        addLeadingComment(followingNode.trueBody, comment);
-      }
+    if (precedingNode.type === "ExpressionStatement") {
+      addTrailingComment(precedingNode, comment);
     } else {
-      addLeadingComment(precedingNode, comment);
+      addDanglingComment(enclosingNode, comment);
     }
     return true;
   }
 
-  if (enclosingNode.trueBody === followingNode) {
-    if (followingNode.type === "Block") {
-      if(followingNode.statements.length === 0) {
-        addDanglingComment(followingNode, comment);
-      } else {
-        addLeadingComment(followingNode.statements[0], comment);
-      }
-    } else {
-      addLeadingComment(followingNode, comment);
-    }
+  if (followingNode.type === "ExpressionStatement") {
+    addBlockStatementFirstComment(followingNode, comment);
     return true;
   }
 
   if (followingNode.type === "IfStatement") {
-    if (followingNode.trueBody.type === "Block") {
-      if(followingNode.trueBody.statements.length === 0) {
-        addDanglingComment(followingNode.trueBody, comment);
-      } else {
-        addLeadingComment(followingNode.trueBody.statements[0], comment);
-      }
-    } else {
-      addLeadingComment(followingNode.trueBody, comment);
-    }
+    addBlockOrNotComment(followingNode.trueBody, comment);
     return true;
   }
 

src/slang-comments/handlers/handle-if-statement-comments.ts

@@ -49,18 +49,7 @@ export default function handleIfStatementComments({
     precedingNode === enclosingNode.body &&
     followingNode === enclosingNode.elseBranch
   ) {
-    if (followingNode.body.variant.kind === NonterminalKind.Block) {
-      addHubNodeFirstComment(followingNode.body.variant.statements, comment);
-    } else if (
-      followingNode.body.variant.kind === NonterminalKind.IfStatement
-    ) {
-      addIfStatementBodyFirstComment(
-        followingNode.body.variant.body.variant,
-        comment
-      );
-    } else {
-      addLeadingComment(followingNode.body.variant, comment);
-    }
+    addTrailingComment(precedingNode.variant, comment);
     return true;
   }
 

src/slang-nodes/IfStatement.ts

@@ -2,6 +2,7 @@ import { doc } from 'prettier';
 import { NonterminalKind } from '@nomicfoundation/slang/kinds/index.js';
 import { printSeparatedItem } from '../slang-printers/print-separated-item.js';
 import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { isLineComment } from '../slang-utils/is-comment.js';
 import { Expression } from './Expression.js';
 import { Statement } from './Statement.js';
 import { ElseBranch } from './ElseBranch.js';
@@ -62,8 +63,12 @@ export class IfStatement implements SlangNode {
           }),
       this.elseBranch
         ? [
-            this.body.variant.kind !== NonterminalKind.Block
-              ? hardline // else on a new line if body is not a block
+            this.body.variant.kind !== NonterminalKind.Block || // else on a new line if body is not a block
+            this.body.variant.comments.some(
+              (comment) =>
+                isLineComment(comment) || comment.placement === 'ownLine'
+            ) // or if body has trailing single line comments or a block comment on a new line
+              ? hardline
               : ' ',
             path.call(print, 'elseBranch')
           ]

src/types.d.ts

@@ -31,6 +31,7 @@ interface BaseComment {
   leading?: boolean;
   trailing?: boolean;
   printed?: boolean;
+  placement?: 'endOfLine' | 'ownLine' | 'remaining';
   precedingNode?: StrictAstNode;
   enclosingNode?: StrictAstNode;
   followingNode?: StrictAstNode;

tests/format/Comments/__snapshots__/format.test.js.snap

@@ -260,18 +260,18 @@ contract Comments7 {
 
 contract Comments8 {
     function someFunction() {
-        if (something) {} else {
-            // comment
-        }
+        if (something) {}
+        // comment
+        else {}
     }
 }
 
 contract Comments8 {
     function someFunction() {
-        if (something) {} else {
-            /* comment
-             * comment */
-        }
+        if (something) {}
+        /* comment
+         * comment */
+        else {}
     }
 }
 

tests/format/Etc/__snapshots__/format.test.js.snap

@@ -129,10 +129,10 @@ contract Contract {
     }
 
     function fun(uint256 a) returns (uint) {
-        if (something) foo();
-        else if (somethingElse)
+        if (something)
+            foo();
             // comment
-            bar();
+        else if (somethingElse) bar();
         else whatever();
         return;
     }

tests/format/IfStatements/__snapshots__/format.test.js.snap

@@ -558,14 +558,17 @@ contract IfStatements {
             // Case 0-9
             if (47 < c && c < 58) {
                 return (true, c - 48);
-            } else if (64 < c && c < 71) {
-                // Case A-F
+            }
+            // Case A-F
+            else if (64 < c && c < 71) {
                 return (true, c - 55);
-            } else if (96 < c && c < 103) {
-                // Case a-f
+            }
+            // Case a-f
+            else if (96 < c && c < 103) {
                 return (true, c - 87);
-            } else {
-                // Else: not a hex char
+            }
+            // Else: not a hex char
+            else {
                 return (false, 0);
             }
         }