657560100

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/tremor-rs/tremor-runtime/commit/<a class=hub.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://git"><a class=hub.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://git"><a class=hub.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://git"><a class=hub.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://git"><a class=hub.com/tremor-rs/tremor-runtime/commit/c60b8615d84587e73c4e1b2defa122865a1af58c">c60b8615d">&lt;a href=&quot;https://github.com/tremor-rs/tremor-runtime/commit/</a><a class="double-link" href="https://github.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/c60b8615d84587e73c4e1b2defa122865a1af58c">c60b8615d</a><a href="https://github.com/tremor-rs/tremor-runtime/commit/c60b8615d84587e73c4e1b2defa122865a1af58c">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tremor-rs/tremor-runtime/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tremor-rs/tremor-runtime/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tremor-rs/tremor-runtime/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tremor-rs/tremor-runtime/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tremor-rs/tremor-runtime/commit/c60b8615d84587e73c4e1b2defa122865a1af58c&quot;&gt;c60b8615d&lt;/a&gt;&lt;a href=&quot;https://github.com/tremor-rs/tremor-runtime/commit/c60b8615d84587e73c4e1b2defa122865a1af58c&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tremor-rs/tremor-runtime/commit/c60b8615d84587e73c4e1b2defa122865a1af58c&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;&am... (continued)

Pull Request Pull Request #819: Add match groups and optimize some

Run Details

854 of 854 new or added lines in 9 files covered. (100.0%)

14279 of 17758 relevant lines covered (80.41%)

3.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.97

/tremor-script/src/ast/base_expr.rs

// Copyright 2020-2021, The Tremor Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Don't cover this file it's only getters

use super::raw::{GroupBy, GroupByInt, ImutExprRaw, PathRaw, TestExprRaw};
use super::{Expr, ImutExprInt, InvokeAggr, NodeMetas, Path, Segment, TestExpr};
use crate::pos::{Location, Range};

#[doc(hidden)]
/// Implements the BaseExpr trait for a given expression
#[macro_export]
macro_rules! impl_expr {
    ($name:ident) => {
        impl<'script> BaseExpr for $name<'script> {
            fn s(&self, _meta: &NodeMetas) -> Location {
                self.start
            }

            fn e(&self, _meta: &NodeMetas) -> Location {
                self.end
            }
            fn mid(&self) -> usize {
                0
            }
        }
    };
}
#[doc(hidden)]
/// Implements the BaseExpr trait for a given expression
#[macro_export]
macro_rules! impl_expr_exraw {
    ($name:ident) => {
        impl<'script, Ex> BaseExpr for $name<'script, Ex>
        where
            <Ex as Upable<'script>>::Target: Expression + 'script,
            Ex: ExpressionRaw<'script> + 'script,
        {
            fn s(&self, _meta: &NodeMetas) -> Location {
                self.start
            }

            fn e(&self, _meta: &NodeMetas) -> Location {
                self.end
            }
            fn mid(&self) -> usize {
                0
            }
        }
    };
}

#[doc(hidden)]
/// Implements the BaseExpr trait for a given expression
#[macro_export]
macro_rules! impl_expr_no_lt {
    ($name:ident) => {
        impl BaseExpr for $name {
            fn s(&self, _meta: &NodeMetas) -> Location {
                self.start
            }

            fn e(&self, _meta: &NodeMetas) -> Location {
                self.end
            }
            fn mid(&self) -> usize {
                0
            }
        }
    };
}

impl BaseExpr for Range {
    fn s(&self, _meta: &NodeMetas) -> Location {
        self.0
    }
    fn e(&self, _meta: &NodeMetas) -> Location {
        self.1
    }
    fn mid(&self) -> usize {
        0
    }
}

#[doc(hidden)]
/// Implements the BaseExpr trait for a given expression
#[macro_export]
macro_rules! impl_expr_mid {
    ($name:ident) => {
        impl<'script> BaseExpr for $name<'script> {
            fn mid(&self) -> usize {
                self.mid
            }
        }
    };
}

#[doc(hidden)]
/// Implements the BaseExpr trait for a given expression that generalizes over Expression
#[macro_export]
macro_rules! impl_expr_ex_mid {
    ($name:ident) => {
        impl<'script, Ex: Expression + 'script> BaseExpr for $name<'script, Ex> {
            fn mid(&self) -> usize {
                self.mid
            }
        }
    };
}

/// A Basic expression that can be turned into a location
pub trait BaseExpr: Clone {
    /// Obtain the metadata id of the expression
    fn mid(&self) -> usize;

    /// The start location of the expression
    fn s(&self, meta: &NodeMetas) -> Location {
        meta.start(self.mid()).unwrap_or_default()
    }
    /// The end location of the expression
    fn e(&self, meta: &NodeMetas) -> Location {
        meta.end(self.mid()).unwrap_or_default()
    }
    /// The span (range) of the expression
    fn extent(&self, meta: &NodeMetas) -> Range {
        Range(self.s(meta), self.e(meta))
    }
}

impl BaseExpr for (Location, Location) {
    fn s(&self, _meta: &NodeMetas) -> Location {
        self.0
    }
    fn e(&self, _meta: &NodeMetas) -> Location {
        self.1
    }
    fn mid(&self) -> usize {
        0
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for ImutExprInt<'script> {
    fn s(&self, meta: &NodeMetas) -> Location {
        match self {
            ImutExprInt::Binary(e) => e.s(meta),
            ImutExprInt::Comprehension(e) => e.s(meta),
            ImutExprInt::Invoke(e)
            | ImutExprInt::Invoke1(e)
            | ImutExprInt::Invoke2(e)
            | ImutExprInt::Invoke3(e) => e.s(meta),
            ImutExprInt::InvokeAggr(e) => e.s(meta),
            ImutExprInt::List(e) => e.s(meta),
            ImutExprInt::Literal(e) => e.s(meta),
            ImutExprInt::Recur(e) => e.s(meta),
            ImutExprInt::Local { mid, .. } | ImutExprInt::Present { mid, .. } => {
                meta.start(*mid).unwrap_or_default()
            }
            ImutExprInt::Match(e) => e.s(meta),
            ImutExprInt::Merge(e) => e.s(meta),
            ImutExprInt::Patch(e) => e.s(meta),
            ImutExprInt::Path(e) => e.s(meta),
            ImutExprInt::Record(e) => e.s(meta),
            ImutExprInt::Unary(e) => e.s(meta),
            ImutExprInt::Bytes(e) => e.s(meta),
            ImutExprInt::String(e) => e.s(meta),
        }
    }

    fn e(&self, meta: &NodeMetas) -> Location {
        match self {
            ImutExprInt::Binary(e) => e.e(meta),
            ImutExprInt::Comprehension(e) => e.e(meta),
            ImutExprInt::Invoke(e)
            | ImutExprInt::Invoke1(e)
            | ImutExprInt::Invoke2(e)
            | ImutExprInt::Invoke3(e) => e.e(meta),
            ImutExprInt::InvokeAggr(e) => e.e(meta),
            ImutExprInt::List(e) => e.e(meta),
            ImutExprInt::Literal(e) => e.e(meta),
            ImutExprInt::Match(e) => e.e(meta),
            ImutExprInt::Merge(e) => e.e(meta),
            ImutExprInt::Patch(e) => e.e(meta),
            ImutExprInt::Path(e) => e.e(meta),
            ImutExprInt::Recur(e) => e.e(meta),
            ImutExprInt::Local { mid, .. } | ImutExprInt::Present { mid, .. } => {
                meta.end(*mid).unwrap_or_default()
            }
            ImutExprInt::Record(e) => e.e(meta),
            ImutExprInt::Unary(e) => e.e(meta),
            ImutExprInt::Bytes(e) => e.e(meta),
            ImutExprInt::String(e) => e.e(meta),
        }
    }
    fn mid(&self) -> usize {
        match self {
            ImutExprInt::Binary(e) => e.mid(),
            ImutExprInt::Comprehension(e) => e.mid(),
            ImutExprInt::Invoke(e)
            | ImutExprInt::Invoke1(e)
            | ImutExprInt::Invoke2(e)
            | ImutExprInt::Invoke3(e) => e.mid(),
            ImutExprInt::InvokeAggr(e) => e.mid(),
            ImutExprInt::List(e) => e.mid(),
            ImutExprInt::Literal(e) => e.mid(),
            ImutExprInt::Match(e) => e.mid(),
            ImutExprInt::Merge(e) => e.mid(),
            ImutExprInt::Patch(e) => e.mid(),
            ImutExprInt::Path(e) => e.mid(),
            ImutExprInt::Recur(e) => e.mid(),
            ImutExprInt::Local { mid, .. } | ImutExprInt::Present { mid, .. } => *mid,
            ImutExprInt::Record(e) => e.mid(),
            ImutExprInt::Unary(e) => e.mid(),
            ImutExprInt::Bytes(e) => e.mid(),
            ImutExprInt::String(e) => e.mid(),
        }
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for Expr<'script> {
    fn mid(&self) -> usize {
        match self {
            Expr::Assign { mid, .. }
            | Expr::AssignMoveLocal { mid, .. }
            | Expr::Drop { mid, .. } => *mid,
            Expr::Comprehension(e) => e.mid(),
            Expr::Emit(e) => e.mid(),
            Expr::Imut(e) => e.mid(),
            Expr::Match(e) => e.mid(),
            Expr::MergeInPlace(e) => e.mid(),
            Expr::PatchInPlace(e) => e.mid(),
            Expr::IfElse(e) => e.mid(),
        }
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for PathRaw<'script> {
    fn s(&self, meta: &NodeMetas) -> Location {
        match self {
            PathRaw::Local(e) => e.s(meta),
            PathRaw::Const(e) => e.s(meta),
            PathRaw::Meta(e) => e.start,
            PathRaw::Event(e) => e.start,
            PathRaw::State(e) => e.start,
            PathRaw::Reserved(e) => e.s(meta),
        }
    }
    fn e(&self, meta: &NodeMetas) -> Location {
        match self {
            PathRaw::Local(e) => e.e(meta),
            PathRaw::Const(e) => e.e(meta),
            PathRaw::Meta(e) => e.end,
            PathRaw::Event(e) => e.end,
            PathRaw::State(e) => e.end,
            PathRaw::Reserved(e) => e.e(meta),
        }
    }
    fn mid(&self) -> usize {
        0
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for Path<'script> {
    fn mid(&self) -> usize {
        match self {
            Path::Const(e) | Path::Local(e) => e.mid(),
            Path::Meta(e) => e.mid(),
            Path::Event(e) => e.mid(),
            Path::State(e) => e.mid(),
            Path::Reserved(e) => e.mid(),
        }
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for Segment<'script> {
    fn mid(&self) -> usize {
        match self {
            Self::Id { mid, .. }
            | Self::Idx { mid, .. }
            | Self::Element { mid, .. }
            | Self::Range { mid, .. } => *mid,
        }
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for ImutExprRaw<'script> {
    fn mid(&self) -> usize {
        0
    }
    fn s(&self, meta: &NodeMetas) -> Location {
        match self {
            ImutExprRaw::Binary(e) => e.start,
            ImutExprRaw::Comprehension(e) => e.start,
            ImutExprRaw::Invoke(e) => e.s(meta),
            ImutExprRaw::List(e) => e.s(meta),
            ImutExprRaw::Literal(e) => e.s(meta),
            ImutExprRaw::Match(e) => e.start,
            ImutExprRaw::Merge(e) => e.start,
            ImutExprRaw::Patch(e) => e.start,
            ImutExprRaw::Path(e) => e.s(meta),
            ImutExprRaw::Present { start, .. } => *start,
            ImutExprRaw::Record(e) => e.s(meta),
            ImutExprRaw::Recur(e) => e.s(meta),
            ImutExprRaw::String(e) => e.start,
            ImutExprRaw::Unary(e) => e.start,
            ImutExprRaw::Bytes(e) => e.start,
        }
    }
    fn e(&self, meta: &NodeMetas) -> Location {
        match self {
            ImutExprRaw::Binary(e) => e.end,
            ImutExprRaw::Comprehension(e) => e.end,
            ImutExprRaw::Invoke(e) => e.e(meta),
            ImutExprRaw::List(e) => e.e(meta),
            ImutExprRaw::Literal(e) => e.e(meta),
            ImutExprRaw::Match(e) => e.end,
            ImutExprRaw::Merge(e) => e.end,
            ImutExprRaw::Patch(e) => e.end,
            ImutExprRaw::Path(e) => e.e(meta),
            ImutExprRaw::Present { end, .. } => *end,
            ImutExprRaw::Record(e) => e.e(meta),
            ImutExprRaw::Recur(e) => e.e(meta),
            ImutExprRaw::String(e) => e.end,
            ImutExprRaw::Unary(e) => e.end,
            ImutExprRaw::Bytes(e) => e.end,
        }
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl BaseExpr for TestExpr {
    fn mid(&self) -> usize {
        self.mid
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl BaseExpr for TestExprRaw {
    fn s(&self, _meta: &NodeMetas) -> Location {
        self.start
    }

    fn e(&self, _meta: &NodeMetas) -> Location {
        self.end
    }
    fn mid(&self) -> usize {
        0
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl BaseExpr for InvokeAggr {
    fn mid(&self) -> usize {
        self.mid
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for GroupBy<'script> {
    fn mid(&self) -> usize {
        self.0.mid()
    }
}

// This is a simple accessor
#[cfg(not(tarpaulin_include))]
impl<'script> BaseExpr for GroupByInt<'script> {
    fn mid(&self) -> usize {
        match self {
            GroupByInt::Expr { mid, .. }
            | GroupByInt::Set { mid, .. }
            | GroupByInt::Each { mid, .. } => *mid,
        }
    }
}

1	// Copyright 2020-2021, The Tremor Team
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	// Don't cover this file it's only getters
16
17	use super::raw::{GroupBy, GroupByInt, ImutExprRaw, PathRaw, TestExprRaw};
18	use super::{Expr, ImutExprInt, InvokeAggr, NodeMetas, Path, Segment, TestExpr};
19	use crate::pos::{Location, Range};
20
21	#[doc(hidden)]
22	/// Implements the BaseExpr trait for a given expression
23	#[macro_export]
24	macro_rules! impl_expr {
25	($name:ident) => {
26	impl<'script> BaseExpr for $name<'script> {
27	fn s(&self, _meta: &NodeMetas) -> Location {	4✔
28	self.start	4✔
29	}
30
31	fn e(&self, _meta: &NodeMetas) -> Location {	4✔
32	self.end	4✔
33	}
34	fn mid(&self) -> usize {	×
35	0
36	}
37	}
38	};
39	}
40	#[doc(hidden)]
41	/// Implements the BaseExpr trait for a given expression
42	#[macro_export]
43	macro_rules! impl_expr_exraw {
44	($name:ident) => {
45	impl<'script, Ex> BaseExpr for $name<'script, Ex>
46	where
47	<Ex as Upable<'script>>::Target: Expression + 'script,
48	Ex: ExpressionRaw<'script> + 'script,
49	{
50	fn s(&self, _meta: &NodeMetas) -> Location {	×
51	self.start	×
52	}
53
54	fn e(&self, _meta: &NodeMetas) -> Location {	×
55	self.end	×
56	}
57	fn mid(&self) -> usize {
58	0
59	}
60	}
61	};
62	}
63
64	#[doc(hidden)]
65	/// Implements the BaseExpr trait for a given expression
66	#[macro_export]
67	macro_rules! impl_expr_no_lt {
68	($name:ident) => {
69	impl BaseExpr for $name {
70	fn s(&self, _meta: &NodeMetas) -> Location {
71	self.start
72	}
73
74	fn e(&self, _meta: &NodeMetas) -> Location {
75	self.end
76	}
77	fn mid(&self) -> usize {
78	0
79	}
80	}
81	};
82	}
83
84	impl BaseExpr for Range {
85	fn s(&self, _meta: &NodeMetas) -> Location {	3✔
86	self.0	3✔
87	}
88	fn e(&self, _meta: &NodeMetas) -> Location {	3✔
89	self.1	3✔
90	}
91	fn mid(&self) -> usize {	×
92	0	×
93	}
94	}
95
96	#[doc(hidden)]
97	/// Implements the BaseExpr trait for a given expression
98	#[macro_export]
99	macro_rules! impl_expr_mid {
100	($name:ident) => {
101	impl<'script> BaseExpr for $name<'script> {
102	fn mid(&self) -> usize {	48✔
103	self.mid	48✔
104	}
105	}
106	};
107	}
108
109	#[doc(hidden)]
110	/// Implements the BaseExpr trait for a given expression that generalizes over Expression
111	#[macro_export]
112	macro_rules! impl_expr_ex_mid {
113	($name:ident) => {
114	impl<'script, Ex: Expression + 'script> BaseExpr for $name<'script, Ex> {
115	fn mid(&self) -> usize {	1✔
116	self.mid	1✔
117	}
118	}
119	};
120	}
121
122	/// A Basic expression that can be turned into a location
123	pub trait BaseExpr: Clone {
124	/// Obtain the metadata id of the expression
125	fn mid(&self) -> usize;
126
127	/// The start location of the expression
128	fn s(&self, meta: &NodeMetas) -> Location {	49✔
129	meta.start(self.mid()).unwrap_or_default()	49✔
130	}
131	/// The end location of the expression
132	fn e(&self, meta: &NodeMetas) -> Location {	49✔
133	meta.end(self.mid()).unwrap_or_default()	49✔
134	}
135	/// The span (range) of the expression
136	fn extent(&self, meta: &NodeMetas) -> Range {	51✔
137	Range(self.s(meta), self.e(meta))	51✔
138	}
139	}
140
141	impl BaseExpr for (Location, Location) {
142	fn s(&self, _meta: &NodeMetas) -> Location {	2✔
143	self.0	2✔
144	}
145	fn e(&self, _meta: &NodeMetas) -> Location {	2✔
146	self.1	2✔
147	}
148	fn mid(&self) -> usize {	×
149	0	×
150	}
151	}
152
153	// This is a simple accessor
154	#[cfg(not(tarpaulin_include))]
155	impl<'script> BaseExpr for ImutExprInt<'script> {
156	fn s(&self, meta: &NodeMetas) -> Location {
157	match self {
158	ImutExprInt::Binary(e) => e.s(meta),
159	ImutExprInt::Comprehension(e) => e.s(meta),
160	ImutExprInt::Invoke(e)
161	\| ImutExprInt::Invoke1(e)
162	\| ImutExprInt::Invoke2(e)
163	\| ImutExprInt::Invoke3(e) => e.s(meta),
164	ImutExprInt::InvokeAggr(e) => e.s(meta),
165	ImutExprInt::List(e) => e.s(meta),
166	ImutExprInt::Literal(e) => e.s(meta),
167	ImutExprInt::Recur(e) => e.s(meta),
168	ImutExprInt::Local { mid, .. } \| ImutExprInt::Present { mid, .. } => {
169	meta.start(*mid).unwrap_or_default()
170	}
171	ImutExprInt::Match(e) => e.s(meta),
172	ImutExprInt::Merge(e) => e.s(meta),
173	ImutExprInt::Patch(e) => e.s(meta),
174	ImutExprInt::Path(e) => e.s(meta),
175	ImutExprInt::Record(e) => e.s(meta),
176	ImutExprInt::Unary(e) => e.s(meta),
177	ImutExprInt::Bytes(e) => e.s(meta),
178	ImutExprInt::String(e) => e.s(meta),
179	}
180	}
181
182	fn e(&self, meta: &NodeMetas) -> Location {
183	match self {
184	ImutExprInt::Binary(e) => e.e(meta),
185	ImutExprInt::Comprehension(e) => e.e(meta),
186	ImutExprInt::Invoke(e)
187	\| ImutExprInt::Invoke1(e)
188	\| ImutExprInt::Invoke2(e)
189	\| ImutExprInt::Invoke3(e) => e.e(meta),
190	ImutExprInt::InvokeAggr(e) => e.e(meta),
191	ImutExprInt::List(e) => e.e(meta),
192	ImutExprInt::Literal(e) => e.e(meta),
193	ImutExprInt::Match(e) => e.e(meta),
194	ImutExprInt::Merge(e) => e.e(meta),
195	ImutExprInt::Patch(e) => e.e(meta),
196	ImutExprInt::Path(e) => e.e(meta),
197	ImutExprInt::Recur(e) => e.e(meta),
198	ImutExprInt::Local { mid, .. } \| ImutExprInt::Present { mid, .. } => {
199	meta.end(*mid).unwrap_or_default()
200	}
201	ImutExprInt::Record(e) => e.e(meta),
202	ImutExprInt::Unary(e) => e.e(meta),
203	ImutExprInt::Bytes(e) => e.e(meta),
204	ImutExprInt::String(e) => e.e(meta),
205	}
206	}
207	fn mid(&self) -> usize {
208	match self {
209	ImutExprInt::Binary(e) => e.mid(),
210	ImutExprInt::Comprehension(e) => e.mid(),
211	ImutExprInt::Invoke(e)
212	\| ImutExprInt::Invoke1(e)
213	\| ImutExprInt::Invoke2(e)
214	\| ImutExprInt::Invoke3(e) => e.mid(),
215	ImutExprInt::InvokeAggr(e) => e.mid(),
216	ImutExprInt::List(e) => e.mid(),
217	ImutExprInt::Literal(e) => e.mid(),
218	ImutExprInt::Match(e) => e.mid(),
219	ImutExprInt::Merge(e) => e.mid(),
220	ImutExprInt::Patch(e) => e.mid(),
221	ImutExprInt::Path(e) => e.mid(),
222	ImutExprInt::Recur(e) => e.mid(),
223	ImutExprInt::Local { mid, .. } \| ImutExprInt::Present { mid, .. } => *mid,
224	ImutExprInt::Record(e) => e.mid(),
225	ImutExprInt::Unary(e) => e.mid(),
226	ImutExprInt::Bytes(e) => e.mid(),
227	ImutExprInt::String(e) => e.mid(),
228	}
229	}
230	}
231
232	// This is a simple accessor
233	#[cfg(not(tarpaulin_include))]
234	impl<'script> BaseExpr for Expr<'script> {
235	fn mid(&self) -> usize {
236	match self {
237	Expr::Assign { mid, .. }
238	\| Expr::AssignMoveLocal { mid, .. }
239	\| Expr::Drop { mid, .. } => *mid,
240	Expr::Comprehension(e) => e.mid(),
241	Expr::Emit(e) => e.mid(),
242	Expr::Imut(e) => e.mid(),
243	Expr::Match(e) => e.mid(),
244	Expr::MergeInPlace(e) => e.mid(),
245	Expr::PatchInPlace(e) => e.mid(),
246	Expr::IfElse(e) => e.mid(),
247	}
248	}
249	}
250
251	// This is a simple accessor
252	#[cfg(not(tarpaulin_include))]
253	impl<'script> BaseExpr for PathRaw<'script> {
254	fn s(&self, meta: &NodeMetas) -> Location {
255	match self {
256	PathRaw::Local(e) => e.s(meta),
257	PathRaw::Const(e) => e.s(meta),
258	PathRaw::Meta(e) => e.start,
259	PathRaw::Event(e) => e.start,
260	PathRaw::State(e) => e.start,
261	PathRaw::Reserved(e) => e.s(meta),
262	}
263	}
264	fn e(&self, meta: &NodeMetas) -> Location {
265	match self {
266	PathRaw::Local(e) => e.e(meta),
267	PathRaw::Const(e) => e.e(meta),
268	PathRaw::Meta(e) => e.end,
269	PathRaw::Event(e) => e.end,
270	PathRaw::State(e) => e.end,
271	PathRaw::Reserved(e) => e.e(meta),
272	}
273	}
274	fn mid(&self) -> usize {
275	0
276	}
277	}
278
279	// This is a simple accessor
280	#[cfg(not(tarpaulin_include))]
281	impl<'script> BaseExpr for Path<'script> {
282	fn mid(&self) -> usize {
283	match self {
284	Path::Const(e) \| Path::Local(e) => e.mid(),
285	Path::Meta(e) => e.mid(),
286	Path::Event(e) => e.mid(),
287	Path::State(e) => e.mid(),
288	Path::Reserved(e) => e.mid(),
289	}
290	}
291	}
292
293	// This is a simple accessor
294	#[cfg(not(tarpaulin_include))]
295	impl<'script> BaseExpr for Segment<'script> {
296	fn mid(&self) -> usize {
297	match self {
298	Self::Id { mid, .. }
299	\| Self::Idx { mid, .. }
300	\| Self::Element { mid, .. }
301	\| Self::Range { mid, .. } => *mid,
302	}
303	}
304	}
305
306	// This is a simple accessor
307	#[cfg(not(tarpaulin_include))]
308	impl<'script> BaseExpr for ImutExprRaw<'script> {
309	fn mid(&self) -> usize {
310	0
311	}
312	fn s(&self, meta: &NodeMetas) -> Location {
313	match self {
314	ImutExprRaw::Binary(e) => e.start,
315	ImutExprRaw::Comprehension(e) => e.start,
316	ImutExprRaw::Invoke(e) => e.s(meta),
317	ImutExprRaw::List(e) => e.s(meta),
318	ImutExprRaw::Literal(e) => e.s(meta),
319	ImutExprRaw::Match(e) => e.start,
320	ImutExprRaw::Merge(e) => e.start,
321	ImutExprRaw::Patch(e) => e.start,
322	ImutExprRaw::Path(e) => e.s(meta),
323	ImutExprRaw::Present { start, .. } => *start,
324	ImutExprRaw::Record(e) => e.s(meta),
325	ImutExprRaw::Recur(e) => e.s(meta),
326	ImutExprRaw::String(e) => e.start,
327	ImutExprRaw::Unary(e) => e.start,
328	ImutExprRaw::Bytes(e) => e.start,
329	}
330	}
331	fn e(&self, meta: &NodeMetas) -> Location {
332	match self {
333	ImutExprRaw::Binary(e) => e.end,
334	ImutExprRaw::Comprehension(e) => e.end,
335	ImutExprRaw::Invoke(e) => e.e(meta),
336	ImutExprRaw::List(e) => e.e(meta),
337	ImutExprRaw::Literal(e) => e.e(meta),
338	ImutExprRaw::Match(e) => e.end,
339	ImutExprRaw::Merge(e) => e.end,
340	ImutExprRaw::Patch(e) => e.end,
341	ImutExprRaw::Path(e) => e.e(meta),
342	ImutExprRaw::Present { end, .. } => *end,
343	ImutExprRaw::Record(e) => e.e(meta),
344	ImutExprRaw::Recur(e) => e.e(meta),
345	ImutExprRaw::String(e) => e.end,
346	ImutExprRaw::Unary(e) => e.end,
347	ImutExprRaw::Bytes(e) => e.end,
348	}
349	}
350	}
351
352	// This is a simple accessor
353	#[cfg(not(tarpaulin_include))]
354	impl BaseExpr for TestExpr {
355	fn mid(&self) -> usize {
356	self.mid
357	}
358	}
359
360	// This is a simple accessor
361	#[cfg(not(tarpaulin_include))]
362	impl BaseExpr for TestExprRaw {
363	fn s(&self, _meta: &NodeMetas) -> Location {
364	self.start
365	}
366
367	fn e(&self, _meta: &NodeMetas) -> Location {
368	self.end
369	}
370	fn mid(&self) -> usize {
371	0
372	}
373	}
374
375	// This is a simple accessor
376	#[cfg(not(tarpaulin_include))]
377	impl BaseExpr for InvokeAggr {
378	fn mid(&self) -> usize {
379	self.mid
380	}
381	}
382
383	// This is a simple accessor
384	#[cfg(not(tarpaulin_include))]
385	impl<'script> BaseExpr for GroupBy<'script> {
386	fn mid(&self) -> usize {
387	self.0.mid()
388	}
389	}
390
391	// This is a simple accessor
392	#[cfg(not(tarpaulin_include))]
393	impl<'script> BaseExpr for GroupByInt<'script> {
394	fn mid(&self) -> usize {
395	match self {
396	GroupByInt::Expr { mid, .. }
397	\| GroupByInt::Set { mid, .. }
398	\| GroupByInt::Each { mid, .. } => *mid,
399	}
400	}
401	}

tremor-rs / tremor-runtime / 657560100

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous