Nyrox commented on code in PR #1435:
URL:
https://github.com/apache/datafusion-sqlparser-rs/pull/1435#discussion_r1848028066
##########
src/tokenizer.rs:
##########
@@ -431,36 +433,143 @@ pub struct Location {
}
impl fmt::Display for Location {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.line == 0 {
return Ok(());
}
- write!(
- f,
- // TODO: use standard compiler location syntax
(<path>:<line>:<col>)
- " at Line: {}, Column: {}",
- self.line, self.column,
- )
+ write!(f, " at Line: {}, Column: {}", self.line, self.column)
+ }
+}
+
+impl fmt::Debug for Location {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "Location({},{})", self.line, self.column)
+ }
+}
+
+impl Location {
+ pub fn of(line: u64, column: u64) -> Self {
+ Self { line, column }
+ }
+
+ pub fn span_to(self, end: Self) -> Span {
+ Span { start: self, end }
+ }
+}
+
+impl From<(u64, u64)> for Location {
+ fn from((line, column): (u64, u64)) -> Self {
+ Self { line, column }
+ }
+}
+
+/// A span of source code locations (start, end)
+#[derive(Eq, PartialEq, Hash, Clone, PartialOrd, Ord, Copy)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct Span {
+ pub start: Location,
+ pub end: Location,
+}
+
+impl fmt::Debug for Span {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "Span({:?}..{:?})", self.start, self.end)
+ }
+}
+
+impl Span {
+ // An empty span (0, 0) -> (0, 0)
+ // We need a const instance for pattern matching
+ const EMPTY: Span = Self::empty();
+
+ pub fn new(start: Location, end: Location) -> Span {
+ Span { start, end }
+ }
+
+ /// Returns an empty span (0, 0) -> (0, 0)
+ /// Empty spans represent no knowledge of source location
+ pub const fn empty() -> Span {
+ Span {
+ start: Location { line: 0, column: 0 },
+ end: Location { line: 0, column: 0 },
+ }
+ }
+
+ /// Returns the smallest Span that contains both `self` and `other`
+ /// If either span is [Span::empty], the other span is returned
+ pub fn union(&self, other: &Span) -> Span {
+ // If either span is empty, return the other
+ // this prevents propagating (0, 0) through the tree
+ match (self, other) {
+ (&Span::EMPTY, _) => *other,
+ (_, &Span::EMPTY) => *self,
+ _ => Span {
+ start: cmp::min(self.start, other.start),
+ end: cmp::max(self.end, other.end),
+ },
+ }
+ }
+
+ /// Same as [Span::union] for `Option<Span>`
+ /// If `other` is `None`, `self` is returned
+ pub fn union_opt(&self, other: &Option<Span>) -> Span {
+ match other {
+ Some(other) => self.union(other),
+ None => *self,
+ }
}
}
/// A [Token] with [Location] attached to it
-#[derive(Debug, Eq, PartialEq, Clone)]
+#[derive(Debug, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct TokenWithLocation {
pub token: Token,
- pub location: Location,
+ pub span: Span,
}
impl TokenWithLocation {
- pub fn new(token: Token, line: u64, column: u64) -> TokenWithLocation {
- TokenWithLocation {
- token,
- location: Location { line, column },
- }
+ pub fn new(token: Token, span: Span) -> TokenWithLocation {
+ TokenWithLocation { token, span }
}
pub fn wrap(token: Token) -> TokenWithLocation {
- TokenWithLocation::new(token, 0, 0)
+ TokenWithLocation::new(token, Span::empty())
+ }
+
+ pub fn at(token: Token, start: Location, end: Location) ->
TokenWithLocation {
+ TokenWithLocation::new(token, Span::new(start, end))
+ }
+}
+
+impl core::hash::Hash for TokenWithLocation {
+ fn hash<H: hash::Hasher>(&self, state: &mut H) {
+ let TokenWithLocation { token, span: _ } = self;
+
+ token.hash(state);
+ }
+}
+
+impl PartialEq<TokenWithLocation> for TokenWithLocation {
+ fn eq(&self, other: &TokenWithLocation) -> bool {
+ let TokenWithLocation { token, span: _ } = self;
+
+ token == &other.token
+ }
+}
+
+impl PartialOrd<TokenWithLocation> for TokenWithLocation {
+ fn partial_cmp(&self, other: &TokenWithLocation) -> Option<cmp::Ordering> {
+ Some(self.cmp(other))
+ }
+}
+
+impl Ord for TokenWithLocation {
+ fn cmp(&self, other: &Self) -> cmp::Ordering {
+ let TokenWithLocation { token, span: _ } = self;
+ token.cmp(&other.token)
Review Comment:
Yeah I think it's fine. Idk. if rust-analyzer can accurately do find
references on trait implementations, but it did not find any, so I think it's
only used upstream where we should have the wrapper now
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscr...@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscr...@datafusion.apache.org
For additional commands, e-mail: github-h...@datafusion.apache.org
