saola-schema-ast 0.1.0

Abstract Syntax Tree representation for Prisma Schema Language
Documentation 
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

use crate::ast::{self};

use super::WithSpan;

#[derive(Debug)]
pub enum ExpressionPosition<'ast> {
    Expression,
    Value(&'ast str),
    Function(&'ast str),
    FunctionArgument(&'ast str, &'ast str),
}

impl<'ast> ExpressionPosition<'ast> {
    pub(crate) fn new(expr: &'ast ast::Expression, position: usize) -> Self {
        match expr {
            ast::Expression::NumericValue(val, span) if span.contains(position) => Self::Value(val),
            ast::Expression::StringValue(val, span) if span.contains(position) => Self::Value(val),
            ast::Expression::ConstantValue(val, span) if span.contains(position) => Self::Value(val),
            ast::Expression::Function(name, args, span) if span.contains(position) => {
                narrow_function_position(args, position, name)
            }
            ast::Expression::Array(exprs, span) if span.contains(position) => {
                for expr in exprs.iter() {
                    match ExpressionPosition::new(expr, position) {
                        ExpressionPosition::Expression => (),
                        e => return e,
                    }
                }

                Self::Expression
            }
            _ => Self::Expression,
        }
    }
}

fn narrow_function_position<'ast>(
    args: &'ast ast::ArgumentsList,
    position: usize,
    name: &'ast str,
) -> ExpressionPosition<'ast> {
    let mut spans: Vec<(Option<&str>, ast::Span)> = args
        .arguments
        .iter()
        .map(|arg| (arg.name.as_ref().map(|n| n.name.as_str()), arg.span()))
        .chain(
            args.empty_arguments
                .iter()
                .map(|arg| (Some(arg.name.name.as_str()), arg.name.span())),
        )
        .collect();

    spans.sort_by_key(|(_, span)| span.start);

    let mut arg_name = None;
    for (name, _) in spans.iter().take_while(|(_, span)| span.start < position) {
        arg_name = Some(*name);
    }

    // If the cursor is after a trailing comma, we're not in an argument.
    if let Some(span) = args.trailing_comma
        && position > span.start
    {
        arg_name = None;
    }

    if let Some(arg_name) = arg_name.flatten() {
        ExpressionPosition::FunctionArgument(name, arg_name)
    } else {
        ExpressionPosition::Function(name)
    }
}