Compare commits
No commits in common. "51ef019fd192f462a345af13247326a334096ec8" and "b0b87c68f26a81d370c804daa4552d50792ae88b" have entirely different histories.
51ef019fd1
...
b0b87c68f2
|
|
@ -380,14 +380,21 @@ pub(crate) fn parse_comment<'a>(source: &'a mut Source) -> Result<bool> {
|
||||||
}
|
}
|
||||||
|
|
||||||
let doc = source.next_if_eq(&'/').is_some();
|
let doc = source.next_if_eq(&'/').is_some();
|
||||||
|
eprintln!("doc comment: {doc}");
|
||||||
loop {
|
loop {
|
||||||
// take until new line
|
// take until new line
|
||||||
source.take_while_inclusive(|&c| c != '\n').for_each(drop);
|
source
|
||||||
|
.take_while_inclusive(|&c| c != '\n')
|
||||||
|
.inspect(|c| eprintln!("skipping comment char: {c}"))
|
||||||
|
.for_each(drop);
|
||||||
|
|
||||||
let mut copy = source.clone();
|
let mut copy = source.clone();
|
||||||
// skip whitespaces after new line to find continuation of comment
|
// skip whitespaces after new line to find continuation of comment
|
||||||
(&mut copy)
|
(&mut copy)
|
||||||
.take_while_ref(|&c| is_things::is_whitespace(c) && c != '\n')
|
.take_while_ref(|&c| {
|
||||||
|
eprintln!("Skipping whitespace: {c}");
|
||||||
|
is_things::is_whitespace(c) && c != '\n'
|
||||||
|
})
|
||||||
.for_each(drop);
|
.for_each(drop);
|
||||||
|
|
||||||
if (copy.next() == Some('/')) && (copy.next() == Some('/')) {
|
if (copy.next() == Some('/')) && (copy.next() == Some('/')) {
|
||||||
|
|
|
||||||
|
|
@ -496,6 +496,8 @@ impl<'a> TokenIterator<'a> {
|
||||||
Some('/') if self.follows("//") => {
|
Some('/') if self.follows("//") => {
|
||||||
let doc = complex_tokens::parse_comment(&mut source).ok()?;
|
let doc = complex_tokens::parse_comment(&mut source).ok()?;
|
||||||
self.offset += source.offset();
|
self.offset += source.offset();
|
||||||
|
eprintln!("next: {:?}", source.next());
|
||||||
|
eprintln!("rest: {:?}", &self.source[self.offset..]);
|
||||||
|
|
||||||
let lexeme = &self.source[start..self.offset];
|
let lexeme = &self.source[start..self.offset];
|
||||||
if doc {
|
if doc {
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,398 +0,0 @@
|
||||||
use crate::{Ast, AstNode, Index};
|
|
||||||
|
|
||||||
pub struct PrettyPrint {
|
|
||||||
lines: Vec<String>,
|
|
||||||
indents: Vec<Indent>,
|
|
||||||
}
|
|
||||||
|
|
||||||
const VERTICAL: &str = "│";
|
|
||||||
const HORIZONTAL: &str = "─";
|
|
||||||
const CONNECTOR: &str = "├";
|
|
||||||
const END_CONNECTOR: &str = "└";
|
|
||||||
const EMPTY: &str = " ";
|
|
||||||
|
|
||||||
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
|
|
||||||
enum Indent {
|
|
||||||
Vertical,
|
|
||||||
End,
|
|
||||||
Empty,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PrettyPrint {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
Self {
|
|
||||||
lines: Vec::new(),
|
|
||||||
indents: Vec::new(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn push_line(&mut self, line: String) {
|
|
||||||
let (last, rest) = self
|
|
||||||
.indents
|
|
||||||
.split_last_mut()
|
|
||||||
.map_or::<(Option<&mut Indent>, &mut [Indent]), _>((None, &mut []), |(last, rest)| {
|
|
||||||
(Some(last), rest)
|
|
||||||
});
|
|
||||||
let rest = rest.iter_mut().map(|indent| match *indent {
|
|
||||||
Indent::Vertical => VERTICAL,
|
|
||||||
Indent::End => {
|
|
||||||
*indent = Indent::Empty;
|
|
||||||
END_CONNECTOR
|
|
||||||
}
|
|
||||||
Indent::Empty => EMPTY,
|
|
||||||
});
|
|
||||||
let last = if let Some(last) = last {
|
|
||||||
match last {
|
|
||||||
Indent::Vertical => CONNECTOR,
|
|
||||||
Indent::End => {
|
|
||||||
*last = Indent::Empty;
|
|
||||||
END_CONNECTOR
|
|
||||||
}
|
|
||||||
Indent::Empty => CONNECTOR,
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
""
|
|
||||||
};
|
|
||||||
|
|
||||||
self.lines.push(
|
|
||||||
rest.chain(std::iter::once(last))
|
|
||||||
.chain(std::iter::once(line.as_str()))
|
|
||||||
.collect::<String>(),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn print(mut self, ast: &Ast) {
|
|
||||||
let root = ast.nodes.len().checked_sub(1).unwrap();
|
|
||||||
self.stuff(ast, Index(root as u32));
|
|
||||||
for line in self.lines {
|
|
||||||
println!("{}", line);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn with_indent<I>(
|
|
||||||
&mut self,
|
|
||||||
mut items: impl DoubleEndedIterator<Item = I>,
|
|
||||||
mut f: impl FnMut(&mut Self, I),
|
|
||||||
) {
|
|
||||||
if let Some(last) = (&mut items).next_back() {
|
|
||||||
self.indents.push(Indent::Vertical);
|
|
||||||
for item in items {
|
|
||||||
f(self, item);
|
|
||||||
}
|
|
||||||
*self.indents.last_mut().unwrap() = Indent::End;
|
|
||||||
f(self, last);
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn stuff(&mut self, ast: &Ast, node: Index) {
|
|
||||||
let mut node = ast.nodes.get(node.0 as usize).unwrap();
|
|
||||||
|
|
||||||
match node {
|
|
||||||
AstNode::Root { files } => {
|
|
||||||
self.push_line(format!(
|
|
||||||
"{} {{num_files: {}}}",
|
|
||||||
node_name(node),
|
|
||||||
files.len()
|
|
||||||
));
|
|
||||||
|
|
||||||
self.with_indent(files.iter(), |this, idx| {
|
|
||||||
this.stuff(ast, *idx);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
AstNode::File { decls } => {
|
|
||||||
self.push_line(format!(
|
|
||||||
"{} {{num_decls: {}}}",
|
|
||||||
node_name(node),
|
|
||||||
decls.len()
|
|
||||||
));
|
|
||||||
|
|
||||||
self.with_indent(decls.iter(), |this, idx| {
|
|
||||||
this.stuff(ast, *idx);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
AstNode::ParameterList(parameters) => {
|
|
||||||
self.push_line(format!(
|
|
||||||
"{}[{}]",
|
|
||||||
node_name(node),
|
|
||||||
parameters.parameters.len()
|
|
||||||
));
|
|
||||||
|
|
||||||
self.with_indent(parameters.parameters.iter(), |this, idx| {
|
|
||||||
this.stuff(ast, *idx);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
AstNode::Parameter(parameter) => {
|
|
||||||
self.push_line(format!(
|
|
||||||
"{} [{}: {}]",
|
|
||||||
node_name(node),
|
|
||||||
parameter.name,
|
|
||||||
parameter.param_type
|
|
||||||
));
|
|
||||||
}
|
|
||||||
AstNode::FunctionDecl(function_decl) => {
|
|
||||||
self.push_line(format!("{} {}", node_name(node), function_decl.name,));
|
|
||||||
self.indents.push(Indent::Vertical);
|
|
||||||
self.push_line(format!("VISIBILITY: {:?}", function_decl.visibility));
|
|
||||||
self.stuff(ast, function_decl.parameter_list);
|
|
||||||
self.push_line(format!("RETURN_TYPE: {}", function_decl.return_type));
|
|
||||||
*self.indents.last_mut().unwrap() = Indent::End;
|
|
||||||
self.stuff(ast, function_decl.body);
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::Block { statements, expr } => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
|
|
||||||
self.with_indent(statements.iter().chain(expr), |this, idx| {
|
|
||||||
this.stuff(ast, *idx);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
AstNode::Constant { ty, value } => {
|
|
||||||
self.push_line(format!("{} [{} := {:?}]", node_name(node), ty, value));
|
|
||||||
}
|
|
||||||
AstNode::NoopExpr => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
}
|
|
||||||
AstNode::Stmt { expr } => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
self.indents.push(Indent::End);
|
|
||||||
self.stuff(ast, *expr);
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::ControlFlow { kind, expr } => todo!(),
|
|
||||||
AstNode::VarDecl {
|
|
||||||
mutable,
|
|
||||||
name,
|
|
||||||
var_type,
|
|
||||||
} => {
|
|
||||||
self.push_line(format!(
|
|
||||||
"{} [{} {}: {}]",
|
|
||||||
node_name(node),
|
|
||||||
name,
|
|
||||||
mutable.then_some(" mut").unwrap_or(""),
|
|
||||||
var_type.map_or("?".to_string(), |ty| format!("{ty}"))
|
|
||||||
));
|
|
||||||
}
|
|
||||||
AstNode::Assignment { dest, expr } => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
self.indents.push(Indent::Vertical);
|
|
||||||
self.push_line("DEST".to_string());
|
|
||||||
self.with_indent(core::iter::once(*dest), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
*self.indents.last_mut().unwrap() = Indent::End;
|
|
||||||
self.push_line("EXPR".to_string());
|
|
||||||
self.with_indent(core::iter::once(*expr), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::GlobalDecl {
|
|
||||||
name,
|
|
||||||
var_type,
|
|
||||||
expr,
|
|
||||||
} => {
|
|
||||||
self.push_line(format!("{} [{}: {}]", node_name(node), name, var_type));
|
|
||||||
self.with_indent(core::iter::once(*expr), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
AstNode::StructDecl { name, fields } => todo!(),
|
|
||||||
AstNode::FieldDecl { name, field_type } => todo!(),
|
|
||||||
AstNode::FieldAccess { expr, field } => todo!(),
|
|
||||||
AstNode::UnresolvedDeclRef { name } => {
|
|
||||||
self.push_line(format!("{} \"{}\"", node_name(node), name,));
|
|
||||||
}
|
|
||||||
AstNode::DeclRef { decl } => {
|
|
||||||
self.push_line(format!("{} @{}", node_name(node), decl.0,));
|
|
||||||
}
|
|
||||||
AstNode::TypeDeclRef { ty } => {
|
|
||||||
self.push_line(format!("{} @{:?}", node_name(node), ty,));
|
|
||||||
}
|
|
||||||
AstNode::ExplicitCast { expr, ty } => {
|
|
||||||
self.push_line(format!("{} {}", node_name(node), ty,));
|
|
||||||
self.indents.push(Indent::End);
|
|
||||||
self.stuff(ast, *expr);
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::Not(expr)
|
|
||||||
| AstNode::Negate(expr)
|
|
||||||
| AstNode::Deref { expr }
|
|
||||||
| AstNode::AddressOf { expr }
|
|
||||||
| AstNode::ValueToPlace { expr }
|
|
||||||
| AstNode::PlaceToValue { expr } => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
self.indents.push(Indent::End);
|
|
||||||
self.stuff(ast, *expr);
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::CallExpr { callee, arguments } => {
|
|
||||||
self.push_line(format!(
|
|
||||||
"{} {{num_args: {}}}",
|
|
||||||
node_name(node),
|
|
||||||
arguments.len()
|
|
||||||
));
|
|
||||||
self.indents.push(Indent::Vertical);
|
|
||||||
self.stuff(ast, *callee);
|
|
||||||
*self.indents.last_mut().unwrap() = Indent::End;
|
|
||||||
self.with_indent(arguments.iter(), |this, arg| {
|
|
||||||
this.stuff(ast, *arg);
|
|
||||||
});
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::Argument { expr } => {
|
|
||||||
self.stuff(ast, *expr);
|
|
||||||
}
|
|
||||||
AstNode::Multiply { left, right }
|
|
||||||
| AstNode::Divide { left, right }
|
|
||||||
| AstNode::Modulus { left, right }
|
|
||||||
| AstNode::Add { left, right }
|
|
||||||
| AstNode::Subtract { left, right }
|
|
||||||
| AstNode::BitOr { left, right }
|
|
||||||
| AstNode::BitAnd { left, right }
|
|
||||||
| AstNode::BitXor { left, right }
|
|
||||||
| AstNode::LogicalOr { left, right }
|
|
||||||
| AstNode::LogicalAnd { left, right }
|
|
||||||
| AstNode::Eq { left, right }
|
|
||||||
| AstNode::NotEq { left, right }
|
|
||||||
| AstNode::Less { left, right }
|
|
||||||
| AstNode::LessEq { left, right }
|
|
||||||
| AstNode::Greater { left, right }
|
|
||||||
| AstNode::GreaterEq { left, right }
|
|
||||||
| AstNode::ShiftLeft { left, right }
|
|
||||||
| AstNode::ShiftRight { left, right } => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
self.with_indent([*left, *right].into_iter(), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
AstNode::Subscript { expr, index } => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
self.indents.push(Indent::Vertical);
|
|
||||||
self.stuff(ast, *expr);
|
|
||||||
*self.indents.last_mut().unwrap() = Indent::End;
|
|
||||||
|
|
||||||
self.push_line("INDEX".to_string());
|
|
||||||
self.with_indent([*index].into_iter(), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::If {
|
|
||||||
condition,
|
|
||||||
then,
|
|
||||||
r#else,
|
|
||||||
} => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
self.indents.push(Indent::Vertical);
|
|
||||||
self.push_line("COND".to_string());
|
|
||||||
self.with_indent([*condition].into_iter(), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
|
|
||||||
self.push_line("THEN".to_string());
|
|
||||||
if let Some(r#else) = r#else {
|
|
||||||
self.with_indent(core::iter::once(*then), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
*self.indents.last_mut().unwrap() = Indent::End;
|
|
||||||
self.push_line("ELSE".to_string());
|
|
||||||
self.with_indent(core::iter::once(*r#else), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
} else {
|
|
||||||
*self.indents.last_mut().unwrap() = Indent::End;
|
|
||||||
self.with_indent(core::iter::once(*then), |this, idx| {
|
|
||||||
this.stuff(ast, idx);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::Else { expr } => {
|
|
||||||
self.push_line(format!("{}", node_name(node),));
|
|
||||||
self.indents.push(Indent::End);
|
|
||||||
self.stuff(ast, *expr);
|
|
||||||
self.indents.pop();
|
|
||||||
}
|
|
||||||
AstNode::Comment { text } => {
|
|
||||||
self.push_line(format!("{} \"{}\"", node_name(node), text,));
|
|
||||||
}
|
|
||||||
AstNode::Attributes { attrs } => {
|
|
||||||
self.push_line(format!(
|
|
||||||
"{} {{num_attrs: {}}}",
|
|
||||||
node_name(node),
|
|
||||||
attrs.len()
|
|
||||||
));
|
|
||||||
self.with_indent(attrs.iter(), |this, &attr| {
|
|
||||||
this.stuff(ast, attr);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
AstNode::Doc { text } => {
|
|
||||||
self.push_line(format!("{} \"{}\"", node_name(node), text,));
|
|
||||||
}
|
|
||||||
|
|
||||||
AstNode::Error { err } => {
|
|
||||||
self.push_line(format!("{} \"{}\"", node_name(node), err,));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn node_name(node: &AstNode) -> &'static str {
|
|
||||||
match node {
|
|
||||||
AstNode::Root { .. } => "ROOT",
|
|
||||||
AstNode::File { .. } => "FILE",
|
|
||||||
AstNode::ParameterList(_) => "PARAMS",
|
|
||||||
AstNode::Parameter(_) => "PARAM",
|
|
||||||
AstNode::FunctionDecl(_) => "FN",
|
|
||||||
AstNode::Block { .. } => "BLOCK",
|
|
||||||
AstNode::Constant { .. } => "CONSTANT",
|
|
||||||
AstNode::NoopExpr => "NOOP",
|
|
||||||
AstNode::Stmt { .. } => "STMT",
|
|
||||||
AstNode::ControlFlow { .. } => "CONTROL_FLOW",
|
|
||||||
AstNode::VarDecl { .. } => "VAR_DECL",
|
|
||||||
AstNode::Assignment { .. } => "ASSIGN",
|
|
||||||
AstNode::GlobalDecl { .. } => "GLOBAL_DECL",
|
|
||||||
AstNode::StructDecl { .. } => "STRUCT",
|
|
||||||
AstNode::FieldDecl { .. } => "FIELD",
|
|
||||||
AstNode::FieldAccess { .. } => "FIELD_ACCESS",
|
|
||||||
AstNode::UnresolvedDeclRef { .. } => "UNRESOLVED_DECL_REF",
|
|
||||||
AstNode::DeclRef { .. } => "DECL_REF",
|
|
||||||
AstNode::TypeDeclRef { .. } => "TYPE_REF",
|
|
||||||
AstNode::ExplicitCast { .. } => "AS",
|
|
||||||
AstNode::Deref { .. } => "DEREF",
|
|
||||||
AstNode::AddressOf { .. } => "ADDR_OF",
|
|
||||||
AstNode::PlaceToValue { .. } => "INTO_VALUE",
|
|
||||||
AstNode::ValueToPlace { .. } => "INTO_PLACE",
|
|
||||||
AstNode::CallExpr { .. } => "CALL",
|
|
||||||
AstNode::Argument { .. } => "ARG",
|
|
||||||
AstNode::Not(_) => "NOT",
|
|
||||||
AstNode::Negate(_) => "NEGATE",
|
|
||||||
AstNode::Multiply { .. } => "MUL",
|
|
||||||
AstNode::Divide { .. } => "DIV",
|
|
||||||
AstNode::Modulus { .. } => "REM",
|
|
||||||
AstNode::Add { .. } => "ADD",
|
|
||||||
AstNode::Subtract { .. } => "SUB",
|
|
||||||
AstNode::BitOr { .. } => "BIT_OR",
|
|
||||||
AstNode::BitAnd { .. } => "BIT_AND",
|
|
||||||
AstNode::BitXor { .. } => "BIT_XOR",
|
|
||||||
AstNode::LogicalOr { .. } => "OR",
|
|
||||||
AstNode::LogicalAnd { .. } => "AND",
|
|
||||||
AstNode::Eq { .. } => "EQ",
|
|
||||||
AstNode::NotEq { .. } => "NEQ",
|
|
||||||
AstNode::Less { .. } => "LT",
|
|
||||||
AstNode::LessEq { .. } => "LEQ",
|
|
||||||
AstNode::Greater { .. } => "GT",
|
|
||||||
AstNode::GreaterEq { .. } => "GEQ",
|
|
||||||
AstNode::ShiftLeft { .. } => "SHL",
|
|
||||||
AstNode::ShiftRight { .. } => "SHR",
|
|
||||||
AstNode::Subscript { .. } => "SUBSCRIPT",
|
|
||||||
AstNode::If { .. } => "IF",
|
|
||||||
AstNode::Else { .. } => "ELSE",
|
|
||||||
AstNode::Comment { .. } => "COMMENT",
|
|
||||||
AstNode::Attributes { .. } => "META",
|
|
||||||
AstNode::Doc { .. } => "DOCS",
|
|
||||||
AstNode::Error { .. } => "ERR",
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,178 +0,0 @@
|
||||||
//! Coming from the ast, we have a `DeclRef` with an interned identifier `ident`
|
|
||||||
//! and want to find the symbol it refers to.
|
|
||||||
//!
|
|
||||||
//! To help, we have a struct keeping track of all accessible scopes. Now, we
|
|
||||||
//! want to look through any accessible scope `s` for a symbol with the name
|
|
||||||
//! `ident`. Thus: `Symbol {scope: `s`, name: `ident`, ..}`.
|
|
||||||
//!
|
|
||||||
//! We might also know the type of the symbol we are looking for, if we want
|
|
||||||
//! to permit fields/variables and methods/functions sharing names.
|
|
||||||
//!
|
|
||||||
//! Since I want to allow variable shadowing for local variables, some strategy
|
|
||||||
//! to differentiate between shadowed variables must be employed:
|
|
||||||
//! - keys of type SymbolKind::Local might point to a list of values with source locations
|
|
||||||
//! - keys might contain source locations.
|
|
||||||
//!
|
|
||||||
//! Any symbol pointed at from within the ast must again point at an ast
|
|
||||||
//! object.
|
|
||||||
//! Thus: `Key` -> `AstIndex`
|
|
||||||
//! Exception: `Key::ScopeByIndex` -> `InternIndex`
|
|
||||||
|
|
||||||
use core::fmt::Debug;
|
|
||||||
use std::collections::BTreeMap;
|
|
||||||
|
|
||||||
use internment::Intern;
|
|
||||||
|
|
||||||
use crate::Index;
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
||||||
pub struct Span(u32);
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
||||||
pub struct Spanned<T>(pub T, Span);
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
||||||
pub enum SymbolKind {
|
|
||||||
__First,
|
|
||||||
Const,
|
|
||||||
Function,
|
|
||||||
Type,
|
|
||||||
__TypeScope,
|
|
||||||
Scope,
|
|
||||||
ParentScope,
|
|
||||||
Parameter(Span),
|
|
||||||
Local(Span),
|
|
||||||
__Last,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
||||||
pub enum Key {
|
|
||||||
ScopeByName {
|
|
||||||
name: Intern<str>,
|
|
||||||
},
|
|
||||||
/// not all scopes have a name, as some are anonymous blocks or otherwise nameless
|
|
||||||
ScopeByIndex {
|
|
||||||
ast: Index,
|
|
||||||
},
|
|
||||||
Symbol {
|
|
||||||
scope: Index,
|
|
||||||
name: Intern<str>,
|
|
||||||
kind: SymbolKind,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Key {
|
|
||||||
pub fn parent(scope: Index) -> Key {
|
|
||||||
Key::Symbol {
|
|
||||||
scope,
|
|
||||||
name: Intern::from(""),
|
|
||||||
kind: SymbolKind::ParentScope,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Copy, Debug)]
|
|
||||||
pub enum Payload {
|
|
||||||
Ast(Index),
|
|
||||||
Name(Intern<str>),
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct Symbols {
|
|
||||||
inner: BTreeMap<Key, Payload>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Debug for Symbols {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
write!(f, "Symbols [")?;
|
|
||||||
if f.alternate() {
|
|
||||||
writeln!(f, "")?;
|
|
||||||
}
|
|
||||||
let entries = self.inner.iter();
|
|
||||||
f.debug_list().entries(entries).finish()?;
|
|
||||||
write!(f, "]")?;
|
|
||||||
if f.alternate() {
|
|
||||||
writeln!(f, "")?;
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// checks for each scope in scopes_in_tree Symbol { scope, kind: SymbolKind::Local, 0}..Symbol { scope, kind: SymbolKind::Scope, u32::MAX}
|
|
||||||
struct SymbolTreePos {
|
|
||||||
scopes_in_scope: Vec<Index>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Symbols {
|
|
||||||
pub fn new() -> Symbols {
|
|
||||||
Self {
|
|
||||||
inner: BTreeMap::new(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn insert_scope(&mut self, name: Intern<str>, ast: Index) {
|
|
||||||
self.inner
|
|
||||||
.insert(Key::ScopeByIndex { ast }, Payload::Name(name));
|
|
||||||
self.inner
|
|
||||||
.insert(Key::ScopeByName { name }, Payload::Ast(ast));
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn find_symbol(&self, scope: Index, name: Intern<str>, loc: Span) -> Option<(Key, Index)> {
|
|
||||||
use SymbolKind::*;
|
|
||||||
let range = self.inner.range(
|
|
||||||
Key::Symbol {
|
|
||||||
scope,
|
|
||||||
name,
|
|
||||||
kind: __First,
|
|
||||||
}..=Key::Symbol {
|
|
||||||
scope,
|
|
||||||
name,
|
|
||||||
kind: Local(loc),
|
|
||||||
},
|
|
||||||
);
|
|
||||||
|
|
||||||
if let Some((&key, &Payload::Ast(index))) = range.rev().next() {
|
|
||||||
Some((key, index))
|
|
||||||
} else {
|
|
||||||
if let Some(&Payload::Ast(parent)) = self.inner.get(&Key::parent(scope)) {
|
|
||||||
self.find_symbol(parent, name, loc)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn find_type_symbol(
|
|
||||||
&self,
|
|
||||||
scope: Index,
|
|
||||||
name: Intern<str>,
|
|
||||||
loc: Span,
|
|
||||||
) -> Option<(Key, Index)> {
|
|
||||||
use SymbolKind::*;
|
|
||||||
let range = self.inner.range(
|
|
||||||
Key::Symbol {
|
|
||||||
scope,
|
|
||||||
name,
|
|
||||||
kind: __First,
|
|
||||||
}..=Key::Symbol {
|
|
||||||
scope,
|
|
||||||
name,
|
|
||||||
kind: __TypeScope,
|
|
||||||
},
|
|
||||||
);
|
|
||||||
|
|
||||||
if let Some((&key, &Payload::Ast(index))) = range.rev().next() {
|
|
||||||
Some((key, index))
|
|
||||||
} else {
|
|
||||||
if let Some(&Payload::Ast(parent)) = self.inner.get(&Key::parent(scope)) {
|
|
||||||
self.find_type_symbol(parent, name, loc)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn insert_symbol(&mut self, scope: Index, name: Intern<str>, kind: SymbolKind, ast: Index) {
|
|
||||||
self.inner
|
|
||||||
.insert(Key::Symbol { scope, name, kind }, Payload::Ast(ast));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in a new issue