summaryrefslogtreecommitdiffstats
path: root/yql/essentials/sql/v1/ide/completion/analysis/global/named_node_visibility.cpp
blob: 11b522eee027c82e9d4cdf63bd6baf3411b1696b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include "named_node_visibility.h"

#include "parse_tree.h"

#include <yql/essentials/sql/v1/ide/pure_ast/narrowing_visitor.h>

#include <util/generic/hash_set.h>

namespace NSQLComplete {

namespace {

class TVisitor: public NSQLPureAST::TSQLv1NarrowingVisitor {
public:
    TVisitor(const TParsedInput& input, THashSet<TString>* visible)
        : NSQLPureAST::TSQLv1NarrowingVisitor(input.Tokens, input.Original.CursorPosition)
        , Visible_(visible)
    {
    }

    std::any visitSql_stmt_core(SQLv1::Sql_stmt_coreContext* ctx) override {
        if (ctx->declare_stmt() ||
            ctx->import_stmt() ||
            ctx->define_action_or_subquery_stmt() ||
            ctx->named_nodes_stmt() ||
            IsEnclosing(ctx)) {
            return visitChildren(ctx);
        }
        return {};
    }

    std::any visitDeclare_stmt(SQLv1::Declare_stmtContext* ctx) override {
        VisitNullableCollecting(ctx->bind_parameter());
        return {};
    }

    std::any visitImport_stmt(SQLv1::Import_stmtContext* ctx) override {
        VisitNullableCollecting(ctx->named_bind_parameter_list());
        return {};
    }

    std::any visitDefine_action_or_subquery_stmt(SQLv1::Define_action_or_subquery_stmtContext* ctx) override {
        if (IsEnclosing(ctx)) {
            VisitNullableCollecting(ctx->action_or_subquery_args());
            return visitChildren(ctx);
        }
        VisitNullableCollecting(ctx->bind_parameter());
        return {};
    }

    std::any visitNamed_nodes_stmt(SQLv1::Named_nodes_stmtContext* ctx) override {
        if (IsEnclosing(ctx)) {
            return visitChildren(ctx);
        }
        VisitNullableCollecting(ctx->bind_parameter_list());
        return {};
    }

    std::any visitFor_stmt(SQLv1::For_stmtContext* ctx) override {
        VisitNullableCollecting(ctx->bind_parameter());
        if (IsEnclosing(ctx)) {
            return visitChildren(ctx);
        }
        return {};
    }

    std::any visitLambda(SQLv1::LambdaContext* ctx) override {
        if (IsEnclosing(ctx)) {
            if (ctx->TOKEN_ARROW()) {
                VisitNullableCollecting(ctx->smart_parenthesis());
            }
            visitChildren(ctx);
        }
        return {};
    }

    std::any visitNamed_bind_parameter(SQLv1::Named_bind_parameterContext* ctx) override {
        VisitNullableCollecting(ctx->bind_parameter(0));
        return {};
    }

    std::any visitBind_parameter(SQLv1::Bind_parameterContext* ctx) override {
        if (IsEnclosing(ctx) || !IsCollecting_) {
            return {};
        }

        TMaybe<std::string> id = GetName(ctx);
        if (id.Empty() || id == "_") {
            return {};
        }

        Visible_->insert(std::move(*id));
        return {};
    }

private:
    void VisitNullableCollecting(antlr4::tree::ParseTree* tree) {
        if (tree == nullptr) {
            return;
        }

        const bool old = std::exchange(IsCollecting_, true);
        visit(tree);
        IsCollecting_ = old;
    }

    THashSet<TString>* Visible_;
    bool IsCollecting_ = false;
};

} // namespace

TVector<TString> VisibleNamedNodes(TParsedInput input) {
    THashSet<TString> visible;
    TVisitor(input, &visible).visit(input.SqlQuery);

    TVector<TString> result(Reserve(visible.size()));
    std::ranges::move(visible, std::back_inserter(result));
    return result;
}

} // namespace NSQLComplete