Merge pull request #172 from prettier-solidity/bugfix/contract_definition_comments

Contract Definition comments

Author: Janther

src/clean.js

@@ -1,6 +1,6 @@
 // eslint-disable-next-line no-unused-vars
 function clean(ast, newObj, parent) {
-  ['code', 'codeStart', 'loc', 'range'].forEach(name => {
+  ['code', 'codeStart', 'loc', 'range', 'raw'].forEach(name => {
     delete newObj[name]; // eslint-disable-line no-param-reassign
   });
 }

src/comments/handler.js

@@ -0,0 +1,93 @@
+const {
+  handleOwnLineComment,
+  handleEndOfLineComment,
+  handleRemainingComment,
+  isBlockComment
+} = require('../prettier-comments/language-js/comments');
+
+const handleContractDefinitionComments = require('./handlers/ContractDefinition');
+
+function solidityHandleOwnLineComment(
+  comment,
+  text,
+  options,
+  ast,
+  isLastComment
+) {
+  const { precedingNode, enclosingNode, followingNode } = comment;
+  const handlerArguments = [
+    text,
+    precedingNode,
+    enclosingNode,
+    followingNode,
+    comment,
+    options
+  ];
+
+  if (
+    handleContractDefinitionComments(...handlerArguments) ||
+    handleOwnLineComment(comment, text, options, ast, isLastComment)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function solidityHandleEndOfLineComment(
+  comment,
+  text,
+  options,
+  ast,
+  isLastComment
+) {
+  const { precedingNode, enclosingNode, followingNode } = comment;
+  const handlerArguments = [
+    text,
+    precedingNode,
+    enclosingNode,
+    followingNode,
+    comment,
+    options
+  ];
+
+  if (
+    handleContractDefinitionComments(...handlerArguments) ||
+    handleEndOfLineComment(comment, text, options, ast, isLastComment)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function solidityHandleRemainingComment(
+  comment,
+  text,
+  options,
+  ast,
+  isLastComment
+) {
+  const { precedingNode, enclosingNode, followingNode } = comment;
+  const handlerArguments = [
+    text,
+    precedingNode,
+    enclosingNode,
+    followingNode,
+    comment,
+    options
+  ];
+
+  if (
+    handleContractDefinitionComments(...handlerArguments) ||
+    handleRemainingComment(comment, text, options, ast, isLastComment)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+module.exports = {
+  handleOwnLineComment: solidityHandleOwnLineComment,
+  handleEndOfLineComment: solidityHandleEndOfLineComment,
+  handleRemainingComment: solidityHandleRemainingComment,
+  isBlockComment
+};

src/comments/handlers/ContractDefinition.js

@@ -0,0 +1,58 @@
+const {
+  util: { addLeadingComment, addTrailingComment, addDanglingComment }
+} = require('prettier');
+const privateUtil = require('../../prettier-comments/common/util');
+
+function handleContractDefinitionComments(
+  text,
+  precedingNode,
+  enclosingNode,
+  followingNode,
+  comment,
+  options
+) {
+  if (!enclosingNode || enclosingNode.type !== 'ContractDefinition') {
+    return false;
+  }
+
+  // We unfortunately have no way using the AST or location of nodes to know
+  // if the comment is positioned before the condition parenthesis:
+  //   contract a is abc /* comment */ {}
+  // The only workaround I found is to look at the next character to see if
+  // it is a {}.
+  const nextCharacter = privateUtil.getNextNonSpaceNonCommentCharacter(
+    text,
+    comment,
+    options.locEnd
+  );
+
+  // The comment is behind the start of the Block `{}` or behind a base contract
+  if (
+    (followingNode && followingNode.type === 'InheritanceSpecifier') ||
+    nextCharacter === '{'
+  ) {
+    // In this scenario the comment belongs to a base contract.
+    //   contract A is B, /* comment for B */ C /* comment for C */ {}
+    if (precedingNode && precedingNode.type === 'InheritanceSpecifier') {
+      addTrailingComment(precedingNode, comment);
+      return true;
+    }
+
+    // In this scenario the comment belongs to the contract's name.
+    //   contract A /* comment for A */ is B, C {}
+    // TODO: at the moment we prepended it but this should be kept after the name.
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  // When the contract is empty and contain comments.
+  // Most likely disabling a linter rule.
+  if (enclosingNode.subNodes.length === 0) {
+    addDanglingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
+module.exports = handleContractDefinitionComments;

src/comments/index.js

@@ -0,0 +1,4 @@
+const handler = require('./handler');
+const printer = require('./printer');
+
+module.exports = { handleComments: handler, printComment: printer };

src/comments/printer.js

@@ -0,0 +1,64 @@
+const {
+  doc: {
+    builders: { concat, hardline, join }
+  }
+} = require('prettier');
+const { hasNewline } = require('../prettier-comments/common/util');
+
+function isIndentableBlockComment(comment) {
+  // If the comment has multiple lines and every line starts with a star
+  // we can fix the indentation of each line. The stars in the `/*` and
+  // `*/` delimiters are not included in the comment value, so add them
+  // back first.
+  const lines = `*${comment.raw}*`.split('\n');
+  return lines.length > 1 && lines.every(line => line.trim()[0] === '*');
+}
+
+function printIndentableBlockComment(comment) {
+  const lines = comment.raw.split('\n');
+
+  return concat([
+    '/*',
+    join(
+      hardline,
+      lines.map((line, index) =>
+        index === 0
+          ? line.trimRight()
+          : ` ${index < lines.length - 1 ? line.trim() : line.trimLeft()}`
+      )
+    ),
+    '*/'
+  ]);
+}
+
+function printComment(commentPath, options) {
+  const comment = commentPath.getValue();
+
+  switch (comment.type) {
+    case 'BlockComment': {
+      if (isIndentableBlockComment(comment)) {
+        const printed = printIndentableBlockComment(comment);
+        // We need to prevent an edge case of a previous trailing comment
+        // printed as a `lineSuffix` which causes the comments to be
+        // interleaved. See https://github.com/prettier/prettier/issues/4412
+        if (
+          comment.trailing &&
+          !hasNewline(options.originalText, options.locStart(comment), {
+            backwards: true
+          })
+        ) {
+          return concat([hardline, printed]);
+        }
+        return printed;
+      }
+
+      return `/*${comment.raw}*/`;
+    }
+    case 'LineComment':
+      return `//${comment.raw.trimRight()}`;
+    default:
+      throw new Error(`Not a comment: ${JSON.stringify(comment)}`);
+  }
+}
+
+module.exports = printComment;

src/index.js

@@ -1,4 +1,6 @@
-const { handleComments } = require('./prettier-comments');
+// const { handleComments } = require('./prettier-comments');
+// const printComment = require('./comments/printer');
+const { handleComments, printComment } = require('./comments');
 
 const massageAstNode = require('./clean');
 const loc = require('./loc');
@@ -22,24 +24,8 @@ const parsers = {
   'solidity-parse': parser
 };
 
-function canAttachComment(node) {
-  return (
-    node.type && node.type !== 'BlockComment' && node.type !== 'LineComment'
-  );
-}
-
-function printComment(commentPath) {
-  const comment = commentPath.getValue();
-  switch (comment.type) {
-    case 'BlockComment': {
-      return `/*${comment.raw}*/`;
-    }
-    case 'LineComment':
-      return `//${comment.raw.trimRight()}`;
-    default:
-      throw new Error(`Not a comment: ${JSON.stringify(comment)}`);
-  }
-}
+const canAttachComment = node =>
+  node.type && node.type !== 'BlockComment' && node.type !== 'LineComment';
 
 // https://prettier.io/docs/en/plugins.html#printers
 const printers = {

src/nodes/Block.js

@@ -5,6 +5,7 @@ const {
 } = require('prettier/standalone');
 
 const printPreservingEmptyLines = require('./print-preserving-empty-lines');
+const printComments = require('./print-comments');
 
 const Block = {
   print: ({ node, options, path, print }) => {
@@ -13,33 +14,18 @@ const Block = {
       return '{}';
     }
 
-    const parts = [
+    return concat([
       '{',
-      indent(line),
-      indent(printPreservingEmptyLines(path, 'statements', options, print))
-    ];
-
-    if (node.comments) {
-      let first = true;
-      path.each(commentPath => {
-        if (first) {
-          first = false;
-        } else {
-          parts.push(indent(line));
-        }
-        const comment = commentPath.getValue();
-        if (comment.trailing || comment.leading) {
-          return;
-        }
-        comment.printed = true;
-        parts.push(options.printer.printComment(commentPath));
-      }, 'comments');
-    }
-
-    parts.push(line);
-    parts.push('}');
-
-    return concat(parts);
+      indent(
+        concat([
+          line,
+          printPreservingEmptyLines(path, 'statements', options, print),
+          printComments(node, path, options)
+        ])
+      ),
+      line,
+      '}'
+    ]);
   }
 };
 

src/nodes/ContractDefinition.js

@@ -6,6 +6,7 @@ const {
 
 const printList = require('./print-list');
 const printPreservingEmptyLines = require('./print-preserving-empty-lines');
+const printComments = require('./print-comments');
 
 const inheritance = (node, path, print) =>
   node.baseContracts.length > 0
@@ -16,10 +17,15 @@ const inheritance = (node, path, print) =>
     : line;
 
 const body = (node, path, options, print) =>
-  node.subNodes.length > 0
+  node.subNodes.length > 0 || node.comments
     ? concat([
-        indent(line),
-        indent(printPreservingEmptyLines(path, 'subNodes', options, print)),
+        indent(
+          concat([
+            line,
+            printPreservingEmptyLines(path, 'subNodes', options, print),
+            printComments(node, path, options)
+          ])
+        ),
         line
       ])
     : '';

src/nodes/print-comments.js

@@ -0,0 +1,24 @@
+const {
+  doc: {
+    builders: { join, line }
+  }
+} = require('prettier');
+
+const printComments = (node, path, options) =>
+  node.comments
+    ? join(
+        line,
+        path
+          .map(commentPath => {
+            const comment = commentPath.getValue();
+            if (comment.trailing || comment.leading) {
+              return null;
+            }
+            comment.printed = true;
+            return options.printer.printComment(commentPath);
+          }, 'comments')
+          .filter(element => element)
+      )
+    : '';
+
+module.exports = printComments;