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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::operator::ExprOperator;
use crate::operator::ExprOperatorName;
use crate::operator::EXPR_OPERATORS;
use crate::token::TokenType;
use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
  pub static ref BINARY_OPERATOR_MAPPING: HashMap<TokenType, &'static ExprOperator> = {
    let mut map = HashMap::<TokenType, &'static ExprOperator>::new();
    map.insert(
      TokenType::Plus,
      &EXPR_OPERATORS[&ExprOperatorName::Addition],
    );
    map.insert(
      TokenType::HyphenChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::Arrow],
    );
    map.insert(TokenType::KeywordAs, &EXPR_OPERATORS[&ExprOperatorName::As]);
    map.insert(
      TokenType::ColonColon,
      &EXPR_OPERATORS[&ExprOperatorName::Bind],
    );
    map.insert(
      TokenType::Ampersand,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseAnd],
    );
    map.insert(
      TokenType::ChevronLeftChevronLeft,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseLeftShift],
    );
    map.insert(
      TokenType::Bar,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseOr],
    );
    map.insert(
      TokenType::ChevronRightChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseRightShift],
    );
    map.insert(
      TokenType::ChevronRightChevronRightChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseUnsignedRightShift],
    );
    map.insert(
      TokenType::Caret,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseXor],
    );
    map.insert(
      TokenType::ParenthesisOpen,
      &EXPR_OPERATORS[&ExprOperatorName::Call],
    );
    map.insert(
      TokenType::BracketOpen,
      &EXPR_OPERATORS[&ExprOperatorName::Index],
    );
    map.insert(
      TokenType::Slash,
      &EXPR_OPERATORS[&ExprOperatorName::Division],
    );
    map.insert(
      TokenType::EqualsEquals,
      &EXPR_OPERATORS[&ExprOperatorName::Equality],
    );
    map.insert(
      TokenType::AsteriskAsterisk,
      &EXPR_OPERATORS[&ExprOperatorName::Exponentiation],
    );
    map.insert(
      TokenType::ChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::GreaterThan],
    );
    map.insert(
      TokenType::ChevronRightEquals,
      &EXPR_OPERATORS[&ExprOperatorName::GreaterThanOrEqual],
    );
    map.insert(
      TokenType::ExclamationEquals,
      &EXPR_OPERATORS[&ExprOperatorName::Inequality],
    );
    map.insert(
      TokenType::ChevronLeft,
      &EXPR_OPERATORS[&ExprOperatorName::LessThan],
    );
    map.insert(
      TokenType::ChevronLeftEquals,
      &EXPR_OPERATORS[&ExprOperatorName::LessThanOrEqual],
    );
    map.insert(
      TokenType::AmpersandAmpersand,
      &EXPR_OPERATORS[&ExprOperatorName::LogicalAnd],
    );
    map.insert(
      TokenType::BarBar,
      &EXPR_OPERATORS[&ExprOperatorName::LogicalOr],
    );
    map.insert(
      TokenType::Dot,
      &EXPR_OPERATORS[&ExprOperatorName::MemberAccess],
    );
    map.insert(
      TokenType::Asterisk,
      &EXPR_OPERATORS[&ExprOperatorName::Multiplication],
    );
    map.insert(
      TokenType::QuestionQuestion,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalCoalescing],
    );
    map.insert(
      TokenType::QuestionDot,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalMemberAccess],
    );
    map.insert(
      TokenType::QuestionBracketOpen,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalIndex],
    );
    map.insert(
      TokenType::QuestionParenthesisOpen,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalCall],
    );
    map.insert(
      TokenType::Percent,
      &EXPR_OPERATORS[&ExprOperatorName::Remainder],
    );
    map.insert(
      TokenType::Hyphen,
      &EXPR_OPERATORS[&ExprOperatorName::Subtraction],
    );
    map
  };
  pub static ref UNARY_OPERATOR_MAPPING: HashMap<TokenType, &'static ExprOperator> = {
    let mut map = HashMap::<TokenType, &'static ExprOperator>::new();
    map.insert(
      TokenType::Exclamation,
      &EXPR_OPERATORS[&ExprOperatorName::Not],
    );
    map.insert(
      TokenType::Hyphen,
      &EXPR_OPERATORS[&ExprOperatorName::Negation],
    );
    map
  };
}