Vendor SourceLocation from ruff

Author: youknowone

Cargo.toml

@@ -12,13 +12,15 @@ include = ["LICENSE", "Cargo.toml", "src/**/*.rs"]
 resolver = "2"
 members = [
     "ast", "core", "literal", "parser",
-    "ruff_text_size",
+    "ruff_text_size", "ruff_source_location",
 ]
 
 [workspace.dependencies]
 rustpython-ast = { path = "ast", version = "0.2.0" }
 rustpython-parser-core = { path = "core", version = "0.2.0" }
 rustpython-literal = { path = "literal", version = "0.2.0" }
+ruff_text_size = { path = "ruff_text_size" }
+ruff_source_location = { path = "ruff_source_location" }
 
 ahash = "0.7.6"
 anyhow = "1.0.45"
@@ -32,9 +34,8 @@ num-traits = "0.2"
 rand = "0.8.5"
 serde = "1.0"
 static_assertions = "1.1"
+once_cell = "1.17.1"
 unicode_names2 = { version = "0.6.0", git = "https://github.com/youknowone/unicode_names2.git", rev = "4ce16aa85cbcdd9cc830410f1a72ef9a235f2fde" }
-ruff_python_ast = { git = "https://github.com/youknowone/ruff.git", rev = "088958e8fda2f74f1ebf315c75db13c232409b13" }
-# ruff_python_ast = { path = "../ruff/crates/ruff_python_ast" }
 
 [profile.dev.package."*"]
 opt-level = 3

core/Cargo.toml

@@ -11,10 +11,10 @@ license = "MIT"
 itertools = { workspace = true }
 num-bigint = { workspace = true }
 num-complex = { workspace = true }
-serde = { version = "1.0.133", optional = true, default-features = false, features = ["derive"] }
-ruff_text_size =  { path = "../ruff_text_size" }
-ruff_python_ast = { workspace = true }
+ruff_text_size =  { workspace = true }
+ruff_source_location = { workspace = true }
 
+serde = { version = "1.0.133", optional = true, default-features = false, features = ["derive"] }
 lz4_flex = "0.9.2"
 
 [features]

core/src/source_code.rs

@@ -1,7 +1,7 @@
 // re-export our public interface
-pub use ruff_python_ast::source_code::*;
+pub use ruff_source_location::*;
 
-pub type LineNumber = ruff_python_ast::source_code::OneIndexed;
+pub type LineNumber = OneIndexed;
 
 #[derive(Debug)]
 pub struct SourceRange {

ruff_source_location/Cargo.toml

@@ -0,0 +1,17 @@
+# NOTE: RUSTPYTHON
+# This crate is not a real crate of ruff, but cut off a part of `ruff_python_ast` and vendored it to avoid cross dependency
+
+[package]
+name = "ruff_source_location"
+version = "0.0.0"
+publish = false
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+
+[dependencies]
+ruff_text_size = { workspace = true, features = ["serde"] }
+
+memchr = "2.5.0"
+once_cell = { workspace = true }

ruff_source_location/src/lib.rs

@@ -0,0 +1,227 @@
+mod line_index;
+// mod locator;
+// pub mod newline;
+
+pub use crate::line_index::{LineIndex, OneIndexed};
+// TODO: RUSTPYTHON; import it later
+// pub use locator::Locator;
+use ruff_text_size::{TextRange, TextSize};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use std::fmt::{Debug, Formatter};
+use std::sync::Arc;
+
+/// Gives access to the source code of a file and allows mapping between [`TextSize`] and [`SourceLocation`].
+#[derive(Debug)]
+pub struct SourceCode<'src, 'index> {
+    text: &'src str,
+    index: &'index LineIndex,
+}
+
+impl<'src, 'index> SourceCode<'src, 'index> {
+    pub fn new(content: &'src str, index: &'index LineIndex) -> Self {
+        Self {
+            text: content,
+            index,
+        }
+    }
+
+    /// Computes the one indexed row and column numbers for `offset`.
+    #[inline]
+    pub fn source_location(&self, offset: TextSize) -> SourceLocation {
+        self.index.source_location(offset, self.text)
+    }
+
+    #[inline]
+    pub fn line_index(&self, offset: TextSize) -> OneIndexed {
+        self.index.line_index(offset)
+    }
+
+    /// Take the source code up to the given [`TextSize`].
+    #[inline]
+    pub fn up_to(&self, offset: TextSize) -> &'src str {
+        &self.text[TextRange::up_to(offset)]
+    }
+
+    /// Take the source code after the given [`TextSize`].
+    #[inline]
+    pub fn after(&self, offset: TextSize) -> &'src str {
+        &self.text[usize::from(offset)..]
+    }
+
+    /// Take the source code between the given [`TextRange`].
+    pub fn slice(&self, range: TextRange) -> &'src str {
+        &self.text[range]
+    }
+
+    pub fn line_start(&self, line: OneIndexed) -> TextSize {
+        self.index.line_start(line, self.text)
+    }
+
+    pub fn line_end(&self, line: OneIndexed) -> TextSize {
+        self.index.line_end(line, self.text)
+    }
+
+    pub fn line_range(&self, line: OneIndexed) -> TextRange {
+        self.index.line_range(line, self.text)
+    }
+
+    /// Returns the source text of the line with the given index
+    #[inline]
+    pub fn line_text(&self, index: OneIndexed) -> &'src str {
+        let range = self.index.line_range(index, self.text);
+        &self.text[range]
+    }
+
+    /// Returns the source text
+    pub fn text(&self) -> &'src str {
+        self.text
+    }
+
+    /// Returns the number of lines
+    #[inline]
+    pub fn line_count(&self) -> usize {
+        self.index.line_count()
+    }
+}
+
+impl PartialEq<Self> for SourceCode<'_, '_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.text == other.text
+    }
+}
+
+impl Eq for SourceCode<'_, '_> {}
+
+/// A Builder for constructing a [`SourceFile`]
+pub struct SourceFileBuilder {
+    name: Box<str>,
+    code: Box<str>,
+    index: Option<LineIndex>,
+}
+
+impl SourceFileBuilder {
+    /// Creates a new builder for a file named `name`.
+    pub fn new<Name: Into<Box<str>>, Code: Into<Box<str>>>(name: Name, code: Code) -> Self {
+        Self {
+            name: name.into(),
+            code: code.into(),
+            index: None,
+        }
+    }
+
+    #[must_use]
+    pub fn line_index(mut self, index: LineIndex) -> Self {
+        self.index = Some(index);
+        self
+    }
+
+    pub fn set_line_index(&mut self, index: LineIndex) {
+        self.index = Some(index);
+    }
+
+    /// Consumes `self` and returns the [`SourceFile`].
+    pub fn finish(self) -> SourceFile {
+        let index = if let Some(index) = self.index {
+            once_cell::sync::OnceCell::with_value(index)
+        } else {
+            once_cell::sync::OnceCell::new()
+        };
+
+        SourceFile {
+            inner: Arc::new(SourceFileInner {
+                name: self.name,
+                code: self.code,
+                line_index: index,
+            }),
+        }
+    }
+}
+
+/// A source file that is identified by its name. Optionally stores the source code and [`LineIndex`].
+///
+/// Cloning a [`SourceFile`] is cheap, because it only requires bumping a reference count.
+#[derive(Clone, Eq, PartialEq)]
+pub struct SourceFile {
+    inner: Arc<SourceFileInner>,
+}
+
+impl Debug for SourceFile {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SourceFile")
+            .field("name", &self.name())
+            .field("code", &self.source_text())
+            .finish()
+    }
+}
+
+impl SourceFile {
+    /// Returns the name of the source file (filename).
+    #[inline]
+    pub fn name(&self) -> &str {
+        &self.inner.name
+    }
+
+    #[inline]
+    pub fn slice(&self, range: TextRange) -> &str {
+        &self.source_text()[range]
+    }
+
+    pub fn to_source_code(&self) -> SourceCode {
+        SourceCode {
+            text: self.source_text(),
+            index: self.index(),
+        }
+    }
+
+    fn index(&self) -> &LineIndex {
+        self.inner
+            .line_index
+            .get_or_init(|| LineIndex::from_source_text(self.source_text()))
+    }
+
+    /// Returns `Some` with the source text if set, or `None`.
+    #[inline]
+    pub fn source_text(&self) -> &str {
+        &self.inner.code
+    }
+}
+
+struct SourceFileInner {
+    name: Box<str>,
+    code: Box<str>,
+    line_index: once_cell::sync::OnceCell<LineIndex>,
+}
+
+impl PartialEq for SourceFileInner {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name && self.code == other.code
+    }
+}
+
+impl Eq for SourceFileInner {}
+
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Copy)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct SourceLocation {
+    pub row: OneIndexed,
+    pub column: OneIndexed,
+}
+
+impl Default for SourceLocation {
+    fn default() -> Self {
+        Self {
+            row: OneIndexed::MIN,
+            column: OneIndexed::MIN,
+        }
+    }
+}
+
+impl Debug for SourceLocation {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SourceLocation")
+            .field("row", &self.row.get())
+            .field("column", &self.column.get())
+            .finish()
+    }
+}