Adding in nodes to handle comments is needed to support other tooling that uses the pa

I thought of a problem if we wanted to add comments to the AST: <div class="highli

Feature Request: Add comment nodes to AST about sqlite-parser HOT 3 OPEN

codeschool commented on July 24, 2024

Feature Request: Add comment nodes to AST

from sqlite-parser.

Comments (3)

nwronski commented on July 24, 2024

I thought of a problem if we wanted to add comments to the AST:

/* comments outside of a statement might work alright */
SELECT pants -- But what about 
FROM -- these kinds of comments
  laundry -- what would the AST look like?
WHERE
  clean = true;

Any ideas? Could we put these in the AST in a way that they wouldn't be disruptive and could also be used to reconstruct the original query with the comments in the right places?

from sqlite-parser.

jdrew1303 commented on July 24, 2024

I've been thinking about this for a little while now and looking around to see what others are doing. I think esprima has a reasonably good way of handling this. They tie the comment to the nearest node as either a leadingComment (before the node) or trailingComment (after the node). They are handled as follows:

// Life, Universe, and Everything
var answer /* this is still legal*/ = 6 * 7; // this is trailing

{
    "type": "Program",
    "body": [
        {
            "type": "VariableDeclaration",
            "declarations": [
                {
                    "type": "VariableDeclarator",
                    "id": {
                        "type": "Identifier",
                        "name": "answer",
                        "trailingComments": [
                            {
                                "type": "Block",
                                "value": " this is still legal",
                                "range": [
                                    45,
                                    69
                                ]
                            }
                        ]
                    },
                    "init": {
                        "type": "BinaryExpression",
                        "operator": "*",
                        "left": {
                            "type": "Literal",
                            "value": 6,
                            "raw": "6"
                        },
                        "right": {
                            "type": "Literal",
                            "value": 7,
                            "raw": "7"
                        },
                        "leadingComments": [
                            {
                                "type": "Block",
                                "value": " this is still legal",
                                "range": [
                                    45,
                                    69
                                ]
                            }
                        ]
                    }
                }
            ],
            "kind": "var",
            "leadingComments": [
                {
                    "type": "Line",
                    "value": " Life, Universe, and Everything",
                    "range": [
                        0,
                        33
                    ]
                }
            ],
            "trailingComments": [
                {
                    "type": "Line",
                    "value": " this is trailing",
                    "range": [
                        79,
                        98
                    ]
                }
            ]
        }
    ],
    "sourceType": "script"
}

The area where it gets a bit weird is inside a function declaration with no args:

function noArg(/* I have no node to attach to*/){};

This creates an innerComment like so:

{
    "type": "Program",
    "body": [
        {
            "type": "FunctionDeclaration",
            "id": {
                "type": "Identifier",
                "name": "noArg"
            },
            "params": [],
            "body": {
                "type": "BlockStatement",
                "body": [],
                "innerComments": [
                    {
                        "type": "Block",
                        "value": " I have no node to attach to",
                        "range": [
                            15,
                            47
                        ]
                    }
                ]
            },
            "generator": false,
            "expression": false
        },
        {
            "type": "EmptyStatement"
        }
    ],
    "sourceType": "script"
}

I'm not sure if this would be needed (or worth the effort initially)? It would still be valid to do this in SQL though. What do you think?

from sqlite-parser.

nwronski commented on July 24, 2024

I want to do this, but it would take huge changes to the entire grammar for the parser. I started experimenting with how this might be done, and came up with something that worked for comments that are between statements, but to get all the inline comments would take grammar changes every time the o rule is used in the grammar, which is ~230 times currently.

from sqlite-parser.

Feature Request: Add comment nodes to AST about sqlite-parser HOT 3 OPEN

Comments (3)

Related Issues (20)

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent