hard reseet
This commit is contained in:
@@ -0,0 +1,3 @@
|
||||
mod source;
|
||||
|
||||
pub use source::*;
|
||||
@@ -0,0 +1,72 @@
|
||||
use serde::{Serialize, Serializer};
|
||||
use crate::Span;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum Severity {
|
||||
Error,
|
||||
Warning,
|
||||
}
|
||||
|
||||
impl Serialize for Severity {
|
||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
S: Serializer,
|
||||
{
|
||||
match self {
|
||||
Severity::Error => serializer.serialize_str("error"),
|
||||
Severity::Warning => serializer.serialize_str("warning"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct Diagnostic {
|
||||
pub severity: Severity,
|
||||
pub code: String,
|
||||
pub message: String,
|
||||
pub span: Span,
|
||||
pub related: Vec<(String, Span)>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct DiagnosticBundle {
|
||||
pub diagnostics: Vec<Diagnostic>,
|
||||
}
|
||||
|
||||
impl DiagnosticBundle {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
diagnostics: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn push(&mut self, diagnostic: Diagnostic) {
|
||||
self.diagnostics.push(diagnostic);
|
||||
}
|
||||
|
||||
pub fn error(code: &str, message: String, span: Span) -> Self {
|
||||
let mut bundle = Self::new();
|
||||
bundle.push(Diagnostic {
|
||||
severity: Severity::Error,
|
||||
code: code.to_string(),
|
||||
message,
|
||||
span,
|
||||
related: Vec::new(),
|
||||
});
|
||||
bundle
|
||||
}
|
||||
|
||||
pub fn has_errors(&self) -> bool {
|
||||
self.diagnostics
|
||||
.iter()
|
||||
.any(|d| matches!(d.severity, Severity::Error))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Diagnostic> for DiagnosticBundle {
|
||||
fn from(diagnostic: Diagnostic) -> Self {
|
||||
let mut bundle = Self::new();
|
||||
bundle.push(diagnostic);
|
||||
bundle
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
use std::collections::HashMap;
|
||||
use crate::FileId;
|
||||
use crate::LineIndex;
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct FileDB {
|
||||
files: Vec<FileData>,
|
||||
uri_to_id: HashMap<String, FileId>,
|
||||
}
|
||||
|
||||
struct FileData {
|
||||
uri: String,
|
||||
text: String,
|
||||
line_index: LineIndex,
|
||||
}
|
||||
|
||||
impl FileDB {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
files: Vec::new(),
|
||||
uri_to_id: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn upsert(&mut self, uri: &str, text: String) -> FileId {
|
||||
if let Some(&id) = self.uri_to_id.get(uri) {
|
||||
let line_index = LineIndex::new(&text);
|
||||
self.files[id.0 as usize] = FileData {
|
||||
uri: uri.to_string(),
|
||||
text,
|
||||
line_index,
|
||||
};
|
||||
id
|
||||
} else {
|
||||
let id = FileId(self.files.len() as u32);
|
||||
let line_index = LineIndex::new(&text);
|
||||
self.files.push(FileData {
|
||||
uri: uri.to_string(),
|
||||
text,
|
||||
line_index,
|
||||
});
|
||||
self.uri_to_id.insert(uri.to_string(), id);
|
||||
id
|
||||
}
|
||||
}
|
||||
|
||||
pub fn file_id(&self, uri: &str) -> Option<FileId> {
|
||||
self.uri_to_id.get(uri).copied()
|
||||
}
|
||||
|
||||
pub fn uri(&self, id: FileId) -> &str {
|
||||
&self.files[id.0 as usize].uri
|
||||
}
|
||||
|
||||
pub fn text(&self, id: FileId) -> &str {
|
||||
&self.files[id.0 as usize].text
|
||||
}
|
||||
|
||||
pub fn line_index(&self, id: FileId) -> &LineIndex {
|
||||
&self.files[id.0 as usize].line_index
|
||||
}
|
||||
|
||||
/// Returns a list of all known file IDs in insertion order.
|
||||
pub fn all_files(&self) -> Vec<FileId> {
|
||||
(0..self.files.len()).map(|i| FileId(i as u32)).collect()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
macro_rules! define_id {
|
||||
($name:ident) => {
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, serde::Serialize, serde::Deserialize)]
|
||||
pub struct $name(pub u32);
|
||||
|
||||
impl $name {
|
||||
pub const INVALID: $name = $name(u32::MAX);
|
||||
|
||||
#[inline]
|
||||
pub const fn as_u32(self) -> u32 { self.0 }
|
||||
|
||||
// Temporary helper for places that still index Vec/slots by usize
|
||||
#[inline]
|
||||
pub const fn as_usize(self) -> usize { self.0 as usize }
|
||||
}
|
||||
|
||||
impl From<u32> for $name {
|
||||
#[inline]
|
||||
fn from(value: u32) -> Self { Self(value) }
|
||||
}
|
||||
|
||||
impl From<$name> for u32 {
|
||||
#[inline]
|
||||
fn from(value: $name) -> Self { value.0 }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
define_id!(FileId);
|
||||
define_id!(NodeId);
|
||||
define_id!(NameId);
|
||||
define_id!(SymbolId);
|
||||
define_id!(TypeId);
|
||||
define_id!(ModuleId);
|
||||
define_id!(ProjectId);
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::collections::HashMap;
|
||||
use std::mem::size_of;
|
||||
|
||||
#[test]
|
||||
fn ids_are_repr_transparent_and_hashable() {
|
||||
assert_eq!(size_of::<FileId>(), 4);
|
||||
assert_eq!(size_of::<NodeId>(), 4);
|
||||
assert_eq!(size_of::<NameId>(), 4);
|
||||
assert_eq!(size_of::<SymbolId>(), 4);
|
||||
assert_eq!(size_of::<TypeId>(), 4);
|
||||
assert_eq!(size_of::<ModuleId>(), 4);
|
||||
assert_eq!(size_of::<ProjectId>(), 4);
|
||||
|
||||
// Hash/Eq usage
|
||||
let mut m: HashMap<SymbolId, &str> = HashMap::new();
|
||||
m.insert(SymbolId(1), "one");
|
||||
assert_eq!(m.get(&SymbolId(1)).copied(), Some("one"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
pub struct LineIndex {
|
||||
line_starts: Vec<u32>,
|
||||
total_len: u32,
|
||||
}
|
||||
|
||||
impl LineIndex {
|
||||
pub fn new(text: &str) -> Self {
|
||||
let mut line_starts = vec![0];
|
||||
for (offset, c) in text.char_indices() {
|
||||
if c == '\n' {
|
||||
line_starts.push((offset + 1) as u32);
|
||||
}
|
||||
}
|
||||
Self {
|
||||
line_starts,
|
||||
total_len: text.len() as u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn offset_to_line_col(&self, offset: u32) -> (u32, u32) {
|
||||
let line = match self.line_starts.binary_search(&offset) {
|
||||
Ok(line) => line as u32,
|
||||
Err(line) => (line - 1) as u32,
|
||||
};
|
||||
let col = offset - self.line_starts[line as usize];
|
||||
(line, col)
|
||||
}
|
||||
|
||||
pub fn line_col_to_offset(&self, line: u32, col: u32) -> Option<u32> {
|
||||
let start = *self.line_starts.get(line as usize)?;
|
||||
let offset = start + col;
|
||||
|
||||
let next_start = self.line_starts.get(line as usize + 1).copied().unwrap_or(self.total_len);
|
||||
if offset < next_start || (offset == next_start && offset == self.total_len) {
|
||||
Some(offset)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
mod ids;
|
||||
mod span;
|
||||
mod file_db;
|
||||
mod name_interner;
|
||||
mod diagnostics;
|
||||
mod line_index;
|
||||
|
||||
pub use ids::*;
|
||||
pub use span::Span;
|
||||
pub use file_db::FileDB;
|
||||
pub use line_index::LineIndex;
|
||||
pub use name_interner::NameInterner;
|
||||
pub use diagnostics::*;
|
||||
@@ -0,0 +1,56 @@
|
||||
use std::collections::HashMap;
|
||||
use crate::NameId;
|
||||
|
||||
#[derive(Debug, Default, Clone)]
|
||||
pub struct NameInterner {
|
||||
names: Vec<String>,
|
||||
ids: HashMap<String, NameId>,
|
||||
}
|
||||
|
||||
impl NameInterner {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
names: Vec::new(),
|
||||
ids: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn intern(&mut self, s: &str) -> NameId {
|
||||
if let Some(id) = self.ids.get(s) {
|
||||
return *id;
|
||||
}
|
||||
|
||||
let id = NameId(self.names.len() as u32);
|
||||
self.names.push(s.to_string());
|
||||
self.ids.insert(self.names[id.0 as usize].clone(), id);
|
||||
id
|
||||
}
|
||||
|
||||
pub fn get(&self, s: &str) -> Option<NameId> {
|
||||
self.ids.get(s).copied()
|
||||
}
|
||||
|
||||
pub fn resolve(&self, id: NameId) -> &str {
|
||||
&self.names[id.0 as usize]
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn interner_intern_resolve_roundtrip() {
|
||||
let mut interner = NameInterner::new();
|
||||
let id = interner.intern("foo");
|
||||
assert_eq!(interner.resolve(id), "foo");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn interner_dedups_strings() {
|
||||
let mut interner = NameInterner::new();
|
||||
let id1 = interner.intern("bar");
|
||||
let id2 = interner.intern("bar");
|
||||
assert_eq!(id1, id2);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
use crate::FileId;
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
|
||||
pub struct Span {
|
||||
pub file: FileId,
|
||||
pub start: u32, // byte offset
|
||||
pub end: u32, // byte offset, exclusive
|
||||
}
|
||||
|
||||
impl Span {
|
||||
#[inline]
|
||||
pub fn new(file: FileId, start: u32, end: u32) -> Self {
|
||||
Self { file, start, end }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn len(&self) -> u32 {
|
||||
self.end.saturating_sub(self.start)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn contains(&self, byte: u32) -> bool {
|
||||
self.start <= byte && byte < self.end
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user