Feat/location linecolumn

src/babel/babel-generator/buffer.hpp

@@ -494,10 +494,10 @@ namespace BabelGenerator::Buffer {
     }
     template<PositionType PROP>
     void _normalizePosition(PTR(Node::Node) node, BASE::position_t columnOffset) {
-      auto const &pos = node->loc<PROP>();
+      auto const &has_pos = node->has_loc<PROP>();
       auto &target = this->_sourcePosition;
 
-      if (pos) {
+      if (has_pos) {
         // target.line = pos.line;
         // TODO: Fix https://github.com/babel/babel/issues/15712 in downstream
         // target.column = std::max(pos.column + columnOffset, 0);

src/babel/babel-generator/generators/classes.hpp

@@ -158,8 +158,8 @@ namespace BabelGenerator::Generators {
     if (!node->isStatic() && !_this.format.preserveFormat) {
       // catch up to property key, avoid line break
       // between member TS modifiers and the property key.
-      // const endLine = node.key.loc?.end?.line;
-      // if (endLine) _this.catchUp(endLine);
+      auto endLine = node->key()->locEndLine(-1);
+      if (endLine >= 0) _this.catchUp(endLine);
     }
 
     classesTsPrintClassMemberModifiers(_this, node);
@@ -201,8 +201,8 @@ namespace BabelGenerator::Generators {
 
     // catch up to property key, avoid line break
     // between member modifiers and the property key.
-    // const endLine = node.key.loc?.end?.line;
-    // if (endLine) _this.catchUp(endLine);
+    auto endLine = node->key()->locEndLine(-1);
+    if (endLine >= 0) _this.catchUp(endLine);
 
     // TS does not support class accessor property yet
     classesTsPrintClassMemberModifiers(_this, node);
@@ -284,9 +284,8 @@ namespace BabelGenerator::Generators {
     if (!_this.format.preserveFormat) {
       // catch up to method key, avoid line break
       // between member modifiers/method heads and the method key.
-      // const endLine = node.key.loc?.end?.line;
-      // auto const& endLine = node->key->locEnd();
-      // if (endLine) _this.catchUp(endLine);
+      auto endLine = node->key()->locEndLine(-1);
+      if (endLine >= 0) _this.catchUp(endLine);
     }
 
     classesTsPrintClassMemberModifiers(_this, node);

src/babel/babel-generator/generators/typescript.hpp

@@ -128,7 +128,7 @@ namespace BabelGenerator::Generators {
 
   template<typename T>
   void maybePrintTrailingCommaOrSemicolon(Printer::Printer &printer, PTR(T) node) {
-    if (!(printer.tokenMap != nullptr) || !node->position().has_start || !node->position().has_end) {
+    if (!(printer.tokenMap != nullptr) || !node->position().has_start() || !node->position().has_end()) {
       printer.semicolon();
       return;
     }

src/babel/babel-generator/printer.hpp

@@ -691,29 +691,29 @@
     void _catchUp(PTR(Node::Node) node) {
       auto const &format = this->format;
       if (!format.preserveFormat) {
-        if (format.retainLines && node && node->loc<PROP>()) {
-          // this->catchUp(loc[prop].line);
+        if (format.retainLines && node && node->has_loc<PROP>()) {
+          this->catchUp(node->locLine<PROP>(-1));
         }
         return;
       }
 
       // catch up to this nodes newline if we're behind
-      auto const &pos = node ? node->loc<PROP>() : std::nullopt;
-      if (pos != std::nullopt)
-        this->_catchUpTo(*pos);
+      auto const &pos = node ? node->has_loc<PROP>() : false;
+      if (pos)
+        this->_catchUpTo(node->loc<PROP>());
     }
 
     void _catchUpTo(BabelParser::Util::Location::Position const &pos) {
-      // const count = line - this->_buf.getCurrentLine();
-      // if (count > 0 && this->_noLineTerminator) {
-      //   // We cannot inject new lines when _noLineTemrinator is set
-      //   // to `true`, or we would generate invalid code.
-      //   return;
-      // }
+      auto count = pos.line() - this->_buf.getCurrentLine();
+      if (count > 0 && this->_noLineTerminator) {
+        // We cannot inject new lines when _noLineTemrinator is set
+        // to `true`, or we would generate invalid code.
+        return;
+      }
 
-      // for (let i = 0; i < count; i++) {
-      //   this->_newline();
-      // }
+      for (size_t i = 0; i < count; i++) {
+        this->_newline();
+      }
 
       // const spacesCount =
       //   count > 0 ? column : column - this->_buf.getCurrentColumn();
@@ -786,8 +786,7 @@
       //    }
 
       auto oldInAux = this->_insideAux;
-      // this->_insideAux = node.loc == null;
-      this->_insideAux = false;
+      this->_insideAux = node->position().has_start() == false;
       this->_maybeAddAuxComment(this->_insideAux && !oldInAux);
 
       bool parenthesized = node->extra().parenthesized;
@@ -819,21 +818,22 @@
       }
 
       bool indentParenthesized = false;
-      // if (
-      //   !shouldPrintParens &&
-      //   this->_noLineTerminator &&
-      //   (node.leadingComments?.some(commentIsNewline) ||
-      //     (this->format.retainLines &&
-      //       node.loc &&
-      //       node.loc.start.line > this->_buf.getCurrentLine()))
-      // ) {
-      //   shouldPrintParens = true;
-      //   indentParenthesized = true;
-      // }
+      if (
+        !shouldPrintParens &&
+        this->_noLineTerminator &&
+        (
+          // node.leadingComments?.some(commentIsNewline) ||
+          (this->format.retainLines &&
+            node->position().has_start() &&
+            node->locStartLine(-1) > this->_buf.getCurrentLine()))
+      ) {
+        shouldPrintParens = true;
+        indentParenthesized = true;
+      }
 
       PTR(Node::Node) oldNoLineTerminatorAfterNode = nullptr;
       bool oldInForStatementInitWasTrue = false;
-      //    if (!shouldPrintParens) {
+      if (!shouldPrintParens) {
       //      noLineTerminatorAfter ||=
       //        parent &&
       //        this->_noLineTerminatorAfterNode === parent &&
@@ -846,7 +846,7 @@
       //          this->_noLineTerminatorAfterNode = node;
       //        }
       //      }
-      //    }
+      }
 
       if (shouldPrintParens) {
         this->token(u"(");
@@ -998,13 +998,12 @@
       if (iter_begin == iter_end) [[unlikely]]
         return;
 
-      bool indent;
+      bool indent = false;
       if (OPT.indent == BASE::Undefined && this->format.retainLines) {
-        // const startLine = nodes->at(0)->locStart()->line;
-        // if (startLine != null && startLine !== this->_buf.getCurrentLine()) {
-        //   indent = true;
-        indent = true;
-        // }
+        auto position = (*iter_begin)->position();
+        if (position.has_start() && position.locStart().line() != this->_buf.getCurrentLine()) {
+          indent = true;
+        }
       } else {
         indent = toBoolean(OPT.indent);
       }
@@ -1047,7 +1046,7 @@
             this->newline(1);
           } else {
             auto nextNode = *iter_next;
-            // newlineOpts.nextNodeStartLine = nextNode.loc?.start.line || 0;
+            nextNodeStartLine = nextNode->locStartLine(0);
 
             this->_printNewline(true, nextNodeStartLine);
           }
@@ -1365,27 +1364,27 @@
     ) {
       // const nodeLoc = node.loc;
       // const len = comments.length;
-      bool hasLoc = node->locStart().has_value();
-      // const nodeStartLine = hasLoc ? nodeLoc.start.line : 0;
-      // const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
+      bool hasLoc = node->position().has_start();
+      auto nodeStartLine = node->locStartLine(0);
+      auto nodeEndLine = node->locEndLine(0);
       int64_t lastLine = 0;
       int64_t leadingCommentNewline = 0;
 
       size_t i = 0;
       for (auto iter = commentsHead; iter != nullptr; iter = iter->next(), i++) {
         auto &comment = *iter;
-        if (comment->commentPos != commentPos) [[unlikely]] {
-          --i;
-          continue;
-        }
+        // if (comment->commentPos != commentPos) [[unlikely]] {
+        //   --i;
+        //   continue;
+        // }
         PRINT_COMMENT_HINT::Value shouldPrint = this->_shouldPrintComment(comment /*, nextToken*/);
         if (shouldPrint == PRINT_COMMENT_HINT::DEFER) {
           hasLoc = false;
           break;
         }
         if (hasLoc && shouldPrint == PRINT_COMMENT_HINT::ALLOW) {
-          auto commentStartLine = comment->locStart().line();
-          auto commentEndLine = comment->locEnd().line();
+          auto commentStartLine = comment->locStartLine(-1);
+          auto commentEndLine = comment->locEndLine(-1);
           if constexpr (commentPos == CommentPosition::Leading) {
             int64_t offset = 0;
             if (i == 0) {
@@ -1404,29 +1403,29 @@
 
             if (comment.next() == nullptr) {
               this->maybeNewline(leadingCommentNewline);
-              // maybeNewline(
-              //   Math.max(nodeStartLine - lastLine, leadingCommentNewline),
-              // );
-              // lastLine = nodeStartLine;
+              maybeNewline(
+                std::max(nodeStartLine - lastLine, leadingCommentNewline)
+              );
+              lastLine = nodeStartLine;
             }
           } else if constexpr (commentPos == CommentPosition::Inner) {
-            // const offset =
-            //   commentStartLine - (i === 0 ? nodeStartLine : lastLine);
+            auto offset =
+              commentStartLine - (i == 0 ? nodeStartLine : lastLine);
             lastLine = commentEndLine;
 
-            // maybeNewline(offset);
+            maybeNewline(offset);
             this->_printComment<COMMENT_SKIP_NEWLINE::ALL>(comment);
 
             if (comment.next() == nullptr) {
-              // maybeNewline(Math.min(1, nodeEndLine - lastLine)); // TODO: Improve here when inner comments processing is stronger
-              // lastLine = nodeEndLine;
+              maybeNewline(std::min<BASE::position_t>(1, nodeEndLine - lastLine)); // TODO: Improve here when inner comments processing is stronger
+              lastLine = nodeEndLine;
             }
           } else {
-            // const offset =
-            //   commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
+            auto offset =
+              commentStartLine - (i == 0 ? nodeEndLine - lineOffset : lastLine);
             lastLine = commentEndLine;
 
-            // maybeNewline(offset);
+            maybeNewline(offset);
             this->_printComment<COMMENT_SKIP_NEWLINE::ALL>(comment);
           }
         } else {
@@ -1436,7 +1435,7 @@
           }
 
           if (commentsHead->next() == nullptr) {
-            bool singleLine = comment->locStart().line() == comment->locEnd().line();
+            bool singleLine = comment->locStartLine(-1) == comment->locEndLine(-1);
 
             bool shouldSkipNewline = singleLine && !BabelTypes::isStatement(node) && !BabelTypes::isClassBody(parent) &&
               !BabelTypes::isTSInterfaceBody(parent) && !BabelTypes::isTSEnumMember(node);

src/babel/babel-parser/parser/comments.hpp

@@ -111,14 +111,14 @@
       auto comments = commentWS.comments;
       if (commentWS.leadingNode != nullptr || commentWS.trailingNode != nullptr) {
         if (commentWS.leadingNode != nullptr) {
-          setTrailingComments(commentWS.leadingNode, comments);
+          setTrailingComments(commentWS.leadingNode->makeComments(this->allocator.node()), comments);
         }
         if (commentWS.trailingNode != nullptr) {
-          setLeadingComments(commentWS.trailingNode, comments);
+          setLeadingComments(commentWS.trailingNode->makeComments(this->allocator.node()), comments);
         }
       } else {
         /*:: invariant(commentWS.containingNode !== null) */
-        auto node = commentWS.containingNode;
+        auto node = commentWS.containingNode->makeComments(this->allocator.node());
         auto commentStart = commentWS.start;
         if (this->input[this->offsetToSourcePos(commentStart) - 1] == CharCodes::comma) {
           // If a commentWhitespace follows a comma and the containingNode allows
@@ -173,16 +173,16 @@
           case Node::Type::ImportDeclaration:
             adjustInnerComments(node, NODES(NODEAS(node, ImportDeclaration)->specifiers), commentWS);
             break;
-          // case "TSEnumDeclaration":
-          //   if (!process.env.BABEL_8_BREAKING) {
-          //     adjustInnerComments(node, node.members, commentWS);
-          //   } else {
-          //     setInnerComments(node, comments);
-          //   }
-          //   break;
-          // case "TSEnumBody":
-          //   adjustInnerComments(node, node.members, commentWS);
-          //   break;
+          case Node::Type::TSEnumDeclaration:
+            if (!BASE::process::env.BABEL_8_BREAKING) {
+              adjustInnerComments(node, NODES(NODEAS(node, TSEnumDeclaration)->members), commentWS);
+            } else {
+              setInnerComments(node, comments);
+            }
+            break;
+          case Node::Type::TSEnumBody:
+            adjustInnerComments(node, NODES(NODEAS(node, TSEnumBody)->members), commentWS);
+            break;
           default:
             {
               setInnerComments(node, comments);

src/babel/babel-parser/parser/expression.hpp

@@ -119,7 +119,7 @@
               // Store the first redefinition's position, otherwise ignore because
               // we are parsing ambiguous pattern
               if (refExpressionErrors->doubleProtoLoc == std::nullopt) {
-                refExpressionErrors->doubleProtoLoc = *key->locStart();
+                refExpressionErrors->doubleProtoLoc = key->locStart();
               }
             } else [[unlikely]] {
               this->raise(Errors::DuplicateProto, key);
@@ -387,7 +387,7 @@
           this->raise(Errors::PrivateInExpectedIn, left, value->string());
         }
 
-        this->classScope->usePrivateName(value, *left->locStart());
+        this->classScope->usePrivateName(value, left->locStart());
       }
 
       auto op = this->state.type;
@@ -1318,7 +1318,7 @@
     // then this method will throw a `PipeTopicUnconfiguredToken` error.
     PTR(Node::Expression)
     finishTopicReference(Node::PositionInfo const &startInfo, Proposal::Value pipeProposal, TokenType tokenType) {
-      if (this->testTopicReferenceConfiguration(pipeProposal, *startInfo.locStart(), tokenType)) {
+      if (this->testTopicReferenceConfiguration(pipeProposal, startInfo.locStart(), tokenType)) {
         // The token matches the plugin’s configuration.
         // The token is therefore a topic reference.
 
@@ -1331,7 +1331,7 @@
             // Raise recoverable errors.
             pipeProposal == Proposal::smart ? Errors::PrimaryTopicNotAllowed : // In this case, `pipeProposal === "hack"` is true.
               Errors::PipeTopicUnbound,
-            *startInfo.locStart()
+            startInfo.locStart()
           );
         }
         // Register the topic reference so that its pipe body knows
@@ -2170,7 +2170,7 @@
         //   IdentifierReference
         //   CoverInitializedName
         // Note: `{ eval } = {}` will be checked in `checkLVal` later.
-        this->checkReservedWord(NODEAS(prop.key, Identifier)->name, *prop.key->locStart(), true, false);
+        this->checkReservedWord(NODEAS(prop.key, Identifier)->name, prop.key->locStart(), true, false);
 
         if constexpr (TIsPattern) {
           prop.value = this->parseMaybeDefault(startLoc, NODEAS(this->cloneIdentifier(NODEAS(prop.key, Identifier)), Pattern));
@@ -2440,9 +2440,9 @@
                       // @ts-expect-error key may not index node
                       !!inter.key
                     ? // @ts-expect-error node.key has been guarded
-                    *inter.key->locEnd()
+                    inter.key->locEnd()
                     //                            : node,
-                    : *inter.position.locEnd()
+                    : inter.position.locEnd()
                 );
               } else {
                 this->raise(Errors::IllegalLanguageModeDirective, inter.position);
@@ -2755,7 +2755,7 @@
     PTR(Node::YieldExpression) parseYield() {
       auto startInfo = this->startNodeInfo();
 
-      this->expressionScope->recordParameterInitializerError(Errors::YieldInParameter, *startInfo.locStart());
+      this->expressionScope->recordParameterInitializerError(Errors::YieldInParameter, startInfo.locStart());
 
       this->next();
       bool delegating = false;