mark/mers
1
0
Fork 0
mirror of https://github.com/Dummi26/mers.git synced 2025-03-10 05:43:53 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

early prototype of a language server

Browse Source 
currently only provides hover info (but that's already quite useful for debugging)
This commit is contained in:
Mark 2023-12-05 23:04:17 +01:00
parent 8b60da8d99
commit 0759b769e0
42 changed files with 892 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,5 +1,6 @@
**/target/
**/Cargo.lock
mers_language_server/mers_language_server
tree-sitter-mers/log.html
tree-sitter-mers/package-lock.json
tree-sitter-mers/node_modules

12
mers_language_server/Cargo.toml Normal file
View File

@ -0,0 +1,12 @@
[package]
name = "mers_language_server"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
mers_lib = { path = "../mers_lib", features = ["parse"] }
tokio = { version = "1.34.0", default-features = false, features = ["macros", "rt", "io-std"] }
tower-lsp = "0.20.0"
line-span = "0.1.5"

484
mers_language_server/src/main.rs Normal file
View File

@ -0,0 +1,484 @@
use std::{collections::HashMap, sync::Arc};
use line_span::LineSpanExt;
use mers_lib::{errors::CheckError, prelude_compile::Source};
use tokio::sync::Mutex;
use tower_lsp::{
lsp_types::{
CodeAction, CodeActionKind, CodeActionOptions, CodeActionOrCommand, CodeActionParams,
CodeActionProviderCapability, CodeActionResponse, DidChangeTextDocumentParams,
DidOpenTextDocumentParams, DocumentChanges, Hover, HoverContents, HoverParams,
HoverProviderCapability, InitializeParams, InitializeResult, InitializedParams,
MarkedString, MessageType, OneOf, OptionalVersionedTextDocumentIdentifier, Position,
ServerCapabilities, TextDocumentEdit, TextDocumentItem, TextDocumentSyncCapability,
TextDocumentSyncKind, TextEdit, WorkDoneProgressOptions, WorkspaceEdit,
},
Client, LanguageServer, LspService, Server,
};
#[tokio::main(flavor = "current_thread")]
async fn main() {
let stdin = tokio::io::stdin();
let stdout = tokio::io::stdout();
let (service, socket) = LspService::new(|client| Backend::new(client));
Server::new(stdin, stdout, socket).serve(service).await;
}
struct Backend {
client: Client,
main_document: Arc<Mutex<Option<tower_lsp::lsp_types::Url>>>,
current_document: Arc<Mutex<Option<tower_lsp::lsp_types::Url>>>,
documents: Arc<Mutex<HashMap<tower_lsp::lsp_types::Url, TextDocumentItem>>>,
last_compiled: Arc<Mutex<Option<ParseCompileCheckResult>>>,
}
impl Backend {
pub fn new(client: Client) -> Self {
Self {
client,
main_document: Arc::new(Mutex::new(None)),
current_document: Arc::new(Mutex::new(None)),
documents: Arc::new(Mutex::new(HashMap::new())),
last_compiled: Arc::new(Mutex::new(None)),
}
}
}
#[tower_lsp::async_trait]
impl LanguageServer for Backend {
async fn did_open(&self, p: DidOpenTextDocumentParams) {
*self.last_compiled.lock().await = None;
let mut md = self.main_document.lock().await;
if md.is_none() {
*md = Some(p.text_document.uri.clone());
}
self.documents
.lock()
.await
.insert(p.text_document.uri.clone(), p.text_document);
}
async fn did_change(&self, p: DidChangeTextDocumentParams) {
*self.last_compiled.lock().await = None;
if let Some(document) = self.documents.lock().await.get_mut(&p.text_document.uri) {
for change in p.content_changes {
if let Some(_range) = change.range {
self.client
.log_message(MessageType::WARNING, "Received incremental document update")
.await;
} else {
document.text = change.text;
}
}
} else {
self.client
.log_message(
MessageType::WARNING,
"Received changes for a document that was never loaded",
)
.await;
}
}
async fn initialize(
&self,
_: InitializeParams,
) -> tower_lsp::jsonrpc::Result<InitializeResult> {
// TODO: PositionEncodingKind, set char to 0-based *byte*-index
Ok(InitializeResult {
capabilities: ServerCapabilities {
hover_provider: Some(HoverProviderCapability::Simple(true)),
code_action_provider: Some(CodeActionProviderCapability::Options(
CodeActionOptions {
code_action_kinds: Some(vec![CodeActionKind::new("Test")]),
work_done_progress_options: WorkDoneProgressOptions::default(),
resolve_provider: None,
},
)),
text_document_sync: Some(TextDocumentSyncCapability::Kind(
TextDocumentSyncKind::FULL,
)),
..Default::default()
},
..Default::default()
})
}
async fn initialized(&self, _: InitializedParams) {
self.client
.log_message(MessageType::INFO, "server initialized!")
.await;
}
async fn shutdown(&self) -> tower_lsp::jsonrpc::Result<()> {
Ok(())
}
async fn hover(&self, params: HoverParams) -> tower_lsp::jsonrpc::Result<Option<Hover>> {
*self.last_compiled.lock().await = None;
let byte_pos = {
match self.main_document.lock().await.as_ref() {
Some(uri) => {
let doc = self.documents.lock().await;
let doc = doc.get(uri);
let doc = doc.map(|doc| doc.text.as_str()).unwrap_or("");
let pos_in_og = get_byte_pos_in_og(
doc,
params.text_document_position_params.position.line as _,
params.text_document_position_params.position.character as _,
);
Some(
mers_lib::prelude_compile::Source::new_from_string(doc.to_owned())
.pos_from_og(pos_in_og, false),
)
}
None => None,
}
};
let mut infos_at_cursor_hook_index = None;
let pcc = self
.parse_compile_check(|i1, i3| {
i1.global.enable_hooks = true;
i3.global.enable_hooks = true;
if let Some(byte_pos) = byte_pos {
let mut i1sia = i1.global.save_info_at.lock().unwrap();
let mut i3sia = i3.global.save_info_at.lock().unwrap();
infos_at_cursor_hook_index = Some((i1sia.len(), i3sia.len()));
i1sia.push((vec![], byte_pos, 2)); // 2 -> ignore outer scope
i3sia.push((vec![], byte_pos, 2)); // -> global error doesn't show up in "local" section
}
})
.await;
Ok(Some(Hover {
contents: HoverContents::Scalar(MarkedString::String(match pcc.as_ref().unwrap() {
ParseCompileCheckResult::NoMainDocument => {
format!("# No main document\n\n(open at least one file!)")
}
ParseCompileCheckResult::MainDocumentNotFound => {
format!("# Main document not found\n\n(probably a bug)")
}
ParseCompileCheckResult::ErrorWhileParsing(_, _, e) => {
format!("# Error (can't parse):\n```\n{e}```")
}
ParseCompileCheckResult::ErrorWhileCompiling(_, _, e, _, info1) => {
let i1sia = info1.global.save_info_at.lock().unwrap();
format!(
"# Error (can't compile):{}\n## Global error:\n\n```\n{e}```",
if let Some(i1) = infos_at_cursor_hook_index.map(|(i, _)| &i1sia[i].0) {
format!(
"\n\n## Local errors:{}\n---\n",
i1.iter()
.filter_map(|(src_range, _info, res)| {
let src_snippet = src_range.in_file().src()
[src_range.start().pos()..src_range.end().pos()]
.replace("\n", " ")
.replace("\r", " ");
match res {
Ok(()) => None,
Err(e) => {
Some(format!("\n- `{src_snippet}`\n```\n{e}```\n"))
}
}
})
.collect::<String>()
)
} else {
format!("")
}
)
}
ParseCompileCheckResult::DoesntPassChecks(_, _, e, _, _, _, info3) => {
let i3sia = info3.global.save_info_at.lock().unwrap();
format!(
"# Error (doesn't pass checks):\n```\n{e}```{}",
if let Some(i3) = infos_at_cursor_hook_index.map(|(_, i)| &i3sia[i].0) {
format!(
"\n\n## Local types:{}",
i3.iter()
.map(|(src_range, _info, res)| {
let src_snippet = src_range.in_file().src()
[src_range.start().pos()..src_range.end().pos()]
.replace("\n", " ")
.replace("\r", " ");
match res {
Ok(local_type) => {
format!("\n- `{src_snippet}` :: `{local_type}`")
}
Err(e) => {
format!(
"\n- `{src_snippet}` :: ! Err !\n```\n{e}```\n"
)
}
}
})
.collect::<String>()
)
} else {
format!("")
}
)
}
ParseCompileCheckResult::Checked(_, _, out_type, _, _, _, info3) => {
let i3sia = info3.global.save_info_at.lock().unwrap();
if let Some(i3) = infos_at_cursor_hook_index.map(|(_, i)| &i3sia[i].0) {
format!(
"## Local types:{}",
i3.iter()
.map(|(src_range, _info, res)| {
let src_snippet = src_range.in_file().src()
[src_range.start().pos()..src_range.end().pos()]
.replace("\n", " ")
.replace("\r", " ");
match res {
Ok(local_type) => {
format!("\n- `{src_snippet}` :: `{local_type}`")
}
Err(e) => {
format!("\n- `{src_snippet}` :: ! Err !\n```\n{e}```\n")
}
}
})
.collect::<String>()
)
} else {
format!("Program's return type: `{out_type}`")
}
}
})),
range: None,
}))
}
async fn code_action(
&self,
params: CodeActionParams,
) -> tower_lsp::jsonrpc::Result<Option<CodeActionResponse>> {
Ok(Some(
if let Some(doc) = self.documents.lock().await.get(&params.text_document.uri) {
let mut src = mers_lib::prelude_compile::Source::new_from_string(doc.text.clone());
let srca = Arc::new(src.clone());
match mers_lib::prelude_compile::parse(&mut src, &srca) {
Err(_) => return Ok(None),
Ok(parsed) => {
let pos_start = srca.pos_from_og(
get_byte_pos_in_og(
srca.src_og(),
params.range.start.line as _,
params.range.start.character as _,
),
false,
);
let pos_end = srca.pos_from_og(
get_byte_pos_in_og(
srca.src_og(),
params.range.end.line as _,
params.range.end.character as _,
),
true,
);
let mut statements = vec![];
iter_over_statements(parsed.as_ref(), &mut |s| {
// Wrap in `( )`
if s.source_range().start().pos() <= pos_start
&& pos_end <= s.source_range().end().pos()
{
statements.push(s);
s.inner_statements()
} else {
vec![]
}
});
let statements = statements
.into_iter()
.rev()
.take(3)
.map(|s| {
(
s.source_range()
.in_file()
.pos_in_og(s.source_range().start().pos(), true),
s.source_range()
.in_file()
.pos_in_og(s.source_range().end().pos(), false),
s,
)
})
.collect::<Vec<_>>();
let mut actions = vec![];
// Wrap in `( )`
for (og_start, og_end, statement) in &statements {
actions.push(CodeActionOrCommand::CodeAction(CodeAction {
title: format!(
"Wrap `{}` in `( )`",
srca.src()[statement.source_range().start().pos()
..statement.source_range().end().pos()]
.trim()
.replace("\n", " ")
.replace("\r", " ")
),
edit: Some(WorkspaceEdit {
changes: None,
document_changes: Some(DocumentChanges::Edits(vec![
TextDocumentEdit {
text_document:
OptionalVersionedTextDocumentIdentifier {
uri: params.text_document.uri.clone(),
version: None,
},
edits: vec![OneOf::Left(TextEdit {
range: tower_lsp::lsp_types::Range {
start: get_lsp_pos_in_og(
statement.source_range().in_file().src_og(),
*og_start,
),
end: get_lsp_pos_in_og(
statement.source_range().in_file().src_og(),
*og_end,
),
},
new_text: format!(
"({})",
&statement.source_range().in_file().src_og()
[*og_start..*og_end]
),
})],
},
])),
..Default::default()
}),
..Default::default()
}));
}
actions
}
}
} else {
return Ok(None);
},
))
}
}
/// Recursively iterate over statements.
fn iter_over_statements<'b, S>(root: S, for_each: &'b mut impl FnMut(S) -> Vec<S>) {
for i in for_each(root) {
iter_over_statements(i, for_each);
}
}
fn get_byte_pos_in_og(og: &str, line: usize, character: usize) -> usize {
let line = og.line_spans().skip(line).next();
if let Some(line) = line {
line.start() + character
} else {
og.len()
}
}
fn get_lsp_pos_in_og(og: &str, pos: usize) -> Position {
let mut fallback = Position {
line: 0,
character: 0,
};
for (line_nr, line) in og.line_spans().enumerate() {
fallback = Position {
line: line_nr as _,
character: line.as_str().len() as _,
};
if pos <= line.end() {
return Position {
line: line_nr as _,
character: (pos.saturating_sub(line.start())).min(line.as_str().len()) as _,
};
}
}
fallback
}
enum ParseCompileCheckResult {
NoMainDocument,
MainDocumentNotFound,
ErrorWhileParsing(Source, Arc<Source>, CheckError),
ErrorWhileCompiling(
Source,
Arc<Source>,
CheckError,
Box<dyn mers_lib::prelude_compile::ParsedMersStatement>,
mers_lib::program::parsed::Info,
),
DoesntPassChecks(
Source,
Arc<Source>,
CheckError,
Box<dyn mers_lib::prelude_compile::ParsedMersStatement>,
Box<dyn mers_lib::prelude_compile::RunMersStatement>,
mers_lib::program::parsed::Info,
mers_lib::program::run::CheckInfo,
),
Checked(
Source,
Arc<Source>,
mers_lib::data::Type,
Box<dyn mers_lib::prelude_compile::ParsedMersStatement>,
Box<dyn mers_lib::prelude_compile::RunMersStatement>,
mers_lib::program::parsed::Info,
mers_lib::program::run::CheckInfo,
),
}
impl Backend {
/// is guaranteed to return `MutexGuard<Some(_)>`.
async fn parse_compile_check(
&self,
func_modify_infos: impl FnOnce(
&mut mers_lib::program::parsed::Info,
&mut mers_lib::program::run::CheckInfo,
),
) -> tokio::sync::MutexGuard<'_, Option<ParseCompileCheckResult>> {
let mut last_compiled = self.last_compiled.lock().await;
if last_compiled.is_none() {
*last_compiled = Some(
if let Some(source) = self.main_document.lock().await.clone() {
if let Some(document) = self.documents.lock().await.get(&source) {
let src_from = match document.uri.to_file_path() {
Ok(path) => mers_lib::parsing::SourceFrom::File(path),
Err(_) => mers_lib::parsing::SourceFrom::Unspecified,
};
let mut src =
mers_lib::prelude_compile::Source::new(src_from, document.text.clone());
let srca = Arc::new(src.clone());
match mers_lib::parsing::parse(&mut src, &srca) {
Err(e) => ParseCompileCheckResult::ErrorWhileParsing(src, srca, e),
Ok(parsed) => {
let (mut i1, _, mut i3) = mers_lib::prelude_compile::Config::new()
.bundle_std()
.infos();
func_modify_infos(&mut i1, &mut i3);
match parsed.compile(
&mut i1,
mers_lib::prelude_compile::CompInfo::default(),
) {
Err(e) => ParseCompileCheckResult::ErrorWhileCompiling(
src, srca, e, parsed, i1,
),
Ok(compiled) => match compiled.check(&mut i3, None) {
Err(e) => ParseCompileCheckResult::DoesntPassChecks(
src, srca, e, parsed, compiled, i1, i3,
),
Ok(out_type) => ParseCompileCheckResult::Checked(
src, srca, out_type, parsed, compiled, i1, i3,
),
},
}
}
}
} else {
ParseCompileCheckResult::MainDocumentNotFound
}
} else {
ParseCompileCheckResult::NoMainDocument
},
);
}
last_compiled
}
}

8
mers_lib/src/data/function.rs
View File

@ -17,6 +17,10 @@ pub struct Function {
pub info_check: Arc<Mutex<CheckInfo>>,
pub out: Arc<dyn Fn(&Type, &mut CheckInfo) -> Result<Type, CheckError> + Send + Sync>,
pub run: Arc<dyn Fn(Data, &mut crate::program::run::Info) -> Data + Send + Sync>,
pub inner_statements: Option<(
Arc<Box<dyn crate::prelude_compile::RunMersStatement>>,
Arc<Box<dyn crate::prelude_compile::RunMersStatement>>,
)>,
}
impl Function {
pub fn with_info_run(&self, info: Arc<Info>) -> Self {
@ -25,6 +29,10 @@ impl Function {
info_check: Arc::clone(&self.info_check),
out: Arc::clone(&self.out),
run: Arc::clone(&self.run),
inner_statements: self
.inner_statements
.as_ref()
.map(|v| (Arc::clone(&v.0), Arc::clone(&v.1))),
}
}
pub fn with_info_check(&self, check: CheckInfo) {

9
mers_lib/src/errors/mod.rs
View File

@ -39,8 +39,12 @@ impl SourceRange {
pub fn end(&self) -> SourcePos {
self.end
}
pub fn in_file(&self) -> &Arc<Source> {
&self.in_file
}
}
pub struct CheckError(Vec<CheckErrorComponent>);
#[derive(Clone)]
pub struct CheckError(pub Vec<CheckErrorComponent>);
#[allow(non_upper_case_globals)]
pub mod error_colors {
use colored::Color;
@ -76,7 +80,8 @@ pub mod error_colors {
pub const BadTypeFromParsed: Color = Color::Blue;
pub const TypeAnnotationNoClosingBracket: Color = Color::Blue;
}
enum CheckErrorComponent {
#[derive(Clone)]
pub enum CheckErrorComponent {
Message(String),
Error(CheckError),
ErrorWithDifferentSource(CheckError),

30
mers_lib/src/parsing/mod.rs
View File

@ -1,5 +1,7 @@
use std::{fmt::Debug, path::PathBuf, sync::Arc};
use line_span::{LineSpan, LineSpanExt};
use crate::{
errors::{CheckError, SourcePos},
program::{self, parsed::block::Block},
@ -306,9 +308,37 @@ impl Source {
}
pos
}
pub fn pos_from_og(&self, mut pos: usize, behind_comment: bool) -> usize {
for (start, comment) in &self.comments {
if *start + comment.len() <= pos {
pos -= comment.len();
} else if *start <= pos {
return if behind_comment {
*start + comment.len()
} else {
*start
};
} else {
break;
}
}
pos
}
pub fn src_og(&self) -> &String {
&self.src_og
}
/// If found, returns `Some((line_nr, line_str, byte_pos_in_line_may_be_out_of_string_bounds))`
pub fn get_line_and_char_from_pos_in_str(
byte_index: usize,
str: &str,
) -> Option<(usize, LineSpan<'_>, usize)> {
for (line, line_span) in str.line_spans().enumerate() {
if line_span.start() <= byte_index {
return Some((line, line_span, byte_index - line_span.start()));
}
}
None
}
}
impl Drop for Source {

9
mers_lib/src/parsing/statements.rs
View File

@ -123,7 +123,7 @@ pub fn parse(
.msg(format!("EOF after `:=`"))
})?;
first = Box::new(program::parsed::init_to::InitTo {
pos_in_src: (pos_in_src, src.get_pos(), srca).into(),
pos_in_src: (first.source_range().start(), src.get_pos(), srca).into(),
target: first,
source,
});
@ -133,7 +133,10 @@ pub fn parse(
src.next_word_allow_colon();
let source = parse(src, srca)?.ok_or_else(|| {
CheckError::new()
.src(vec![((pos_in_src, src.get_pos(), srca).into(), None)])
.src(vec![(
(first.source_range().start(), src.get_pos(), srca).into(),
None,
)])
.msg(format!("EOF after `=`"))
})?;
first = Box::new(program::parsed::assign_to::AssignTo {
@ -155,7 +158,7 @@ pub fn parse(
Err(e) => return Err(e),
};
first = Box::new(program::parsed::function::Function {
pos_in_src: (pos_in_src, src.get_pos(), srca).into(),
pos_in_src: (first.source_range().start(), src.get_pos(), srca).into(),
arg: first,
run,
});

16
mers_lib/src/program/configs/with_base.rs
View File

@ -112,7 +112,8 @@ impl Config {
}
}
unreachable!("try: no function found")
})
}),
inner_statements: None,
}))
.add_var("lock_update".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
@ -160,7 +161,8 @@ impl Config {
let func = func.as_any().downcast_ref::<data::function::Function>().unwrap();
*arg = func.run(arg.clone());
Data::empty_tuple()
})
}),
inner_statements: None,
}))
.add_var("sleep".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
@ -183,7 +185,8 @@ impl Config {
unreachable!("sleep called on non-int/non-float")
});
Data::empty_tuple()
})
}),
inner_statements: None,
}))
.add_var("panic".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
@ -195,7 +198,8 @@ impl Config {
}),
run: Arc::new(|a, _i| {
std::process::exit(a.get().as_any().downcast_ref::<data::int::Int>().map(|i| i.0 as _).unwrap_or(1));
})
}),
inner_statements: None,
}))
.add_var(
"len".to_string(),
@ -222,6 +226,7 @@ impl Config {
unreachable!("called len on {a:?}, which isn't a tuple or a string")
}))
}),
inner_statements: None,
}),
).add_var(
"loop".to_string(),
@ -270,6 +275,7 @@ impl Config {
}
}
}),
inner_statements: None,
}),
)
.add_var(
@ -303,6 +309,7 @@ impl Config {
false
}))
}),
inner_statements: None,
}),
)
.add_var(
@ -323,6 +330,7 @@ impl Config {
unreachable!("called deref on non-reference")
}
}),
inner_statements: None,
}),
)
}

1
mers_lib/src/program/configs/with_command_running.rs
View File

@ -76,6 +76,7 @@ impl Config {
unreachable!("run_command called with non-tuple argument")
}
}),
inner_statements: None,
}),
)
}

1
mers_lib/src/program/configs/with_get.rs
View File

@ -66,6 +66,7 @@ impl Config {
unreachable!("get called with less than 2 args")
}
}),
inner_statements: None,
}),
)
}

4
mers_lib/src/program/configs/with_iters.rs
View File

@ -98,6 +98,7 @@ impl Config {
unreachable!("for_each called on non-tuple")
}
}),
inner_statements: None,
}),
)
.add_var(
@ -133,6 +134,7 @@ impl Config {
Ok(Type::new(IterT::new(ItersT::Enumerate, data)?))
}),
run: Arc::new(|a, _i| Data::new(Iter(Iters::Enumerate, a.clone()))),
inner_statements: None,
}),
)
}
@ -203,6 +205,7 @@ fn genfunc_iter_and_arg<T: MersType, D: MersData>(
unreachable!("{name} called on non-tuple")
}
}),
inner_statements: None,
}
}
@ -408,5 +411,6 @@ fn genfunc_iter_in_val_out(
}
}),
run: Arc::new(run),
inner_statements: None,
}
}

4
mers_lib/src/program/configs/with_list.rs
View File

@ -94,6 +94,7 @@ impl Config {
};
o
}),
inner_statements: None,
}))
.add_var(
"pop".to_string(),
@ -140,6 +141,7 @@ impl Config {
None => Data::empty_tuple(),
}
}),
inner_statements: None,
}),
)
.add_var(
@ -202,6 +204,7 @@ impl Config {
.push(Arc::new(RwLock::new(tuple.0[1].clone())));
Data::empty_tuple()
}),
inner_statements: None,
}),
)
.add_var(
@ -225,6 +228,7 @@ impl Config {
unreachable!("as_list called on non-iterable")
}
}),
inner_statements: None,
}),
)
}

15
mers_lib/src/program/configs/with_math.rs
View File

@ -75,7 +75,8 @@ impl Config {
} else {
Data::empty_tuple()
}
})
}),
inner_statements: None,
})).add_var("parse_int".to_string(), Data::new(data::function::Function {
info: Arc::new(program::run::Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -95,7 +96,8 @@ impl Config {
} else {
Data::empty_tuple()
}
})
}),
inner_statements: None,
})).add_var("signum".to_string(), Data::new(data::function::Function {
info: Arc::new(program::run::Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -118,7 +120,8 @@ impl Config {
} else { 0
}
} else { unreachable!("called signum on non-number type")}))
})
}),
inner_statements: None,
})) .add_var("div".to_string(), Data::new(data::function::Function {
info: Arc::new(program::run::Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -137,6 +140,7 @@ impl Config {
_ => unreachable!(),
}
} else { unreachable!() }),
inner_statements: None,
})).add_var("modulo".to_string(), Data::new(data::function::Function {
info: Arc::new(program::run::Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -155,6 +159,7 @@ impl Config {
_ => unreachable!(),
}
} else { unreachable!() }),
inner_statements: None,
}))
.add_var(
"sum".to_string(),
@ -215,6 +220,7 @@ impl Config {
unreachable!("sum called on non-tuple")
}
}),
inner_statements: None,
}),
)
.add_var(
@ -288,6 +294,7 @@ impl Config {
unreachable!("sum called on non-tuple")
}
}),
inner_statements: None,
}),
)
.add_var(
@ -349,6 +356,7 @@ impl Config {
unreachable!("product called on non-tuple")
}
}),
inner_statements: None,
}),
)
}
@ -428,6 +436,7 @@ fn ltgtoe_function(
}
Data::new(data::bool::Bool(true))
}),
inner_statements: None,
}
}
#[derive(Clone, Copy)]

7
mers_lib/src/program/configs/with_multithreading.rs
View File

@ -58,6 +58,7 @@ impl Config {
unreachable!("thread called, but arg wasn't a function");
}
}),
inner_statements: None,
}),
)
.add_var("thread_finished".to_string(), Data::new(data::function::Function {
@ -78,7 +79,8 @@ impl Config {
Ok(t) => t.is_finished(),
Err(_d) => true,
}))
})
}),
inner_statements: None,
}))
.add_var("thread_await".to_string(), Data::new(data::function::Function {
info: Arc::new(program::run::Info::neverused()),
@ -103,7 +105,8 @@ impl Config {
};
*t = Err(d.clone());
d
})
}),
inner_statements: None,
}))
}
}

6
mers_lib/src/program/configs/with_stdio.rs
View File

@ -42,6 +42,7 @@ impl Config {
_ = std::io::stdin().read_line(&mut line);
Data::new(data::string::String(line))
}),
inner_statements: None,
}),
)
.add_var(
@ -55,6 +56,7 @@ impl Config {
eprintln!("{} :: {}", a.as_type(), a);
Data::empty_tuple()
}),
inner_statements: None,
}),
)
.add_var(
@ -68,6 +70,7 @@ impl Config {
_ = std::io::stderr().lock().flush();
Data::empty_tuple()
}),
inner_statements: None,
}),
)
.add_var(
@ -80,6 +83,7 @@ impl Config {
eprintln!("{}", a.get());
Data::empty_tuple()
}),
inner_statements: None,
}),
)
.add_var(
@ -93,6 +97,7 @@ impl Config {
_ = std::io::stdout().lock().flush();
Data::empty_tuple()
}),
inner_statements: None,
}),
)
.add_var(
@ -105,6 +110,7 @@ impl Config {
println!("{}", a.get());
Data::empty_tuple()
}),
inner_statements: None,
}),
)
}

8
mers_lib/src/program/configs/with_string.rs
View File

@ -25,7 +25,8 @@ impl Config {
}),
run: Arc::new(|a, _i| {
Data::new(data::string::String(a.get().as_any().downcast_ref::<data::string::String>().unwrap().0.trim().to_owned()))
})
}),
inner_statements: None,
})).add_var("concat".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -35,11 +36,13 @@ impl Config {
Err(format!("concat called on non-iterable type {a}").into())
}),
run: Arc::new(|a, _i| Data::new(data::string::String(a.get().iterable().unwrap().map(|v| v.get().to_string()).collect()))),
inner_statements: None,
})).add_var("to_string".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
out: Arc::new(|_a, _i| Ok(Type::new(data::string::StringT))),
run: Arc::new(|a, _i| Data::new(data::string::String(a.get().to_string()))),
inner_statements: None,
})).add_var("index_of".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -52,6 +55,7 @@ impl Config {
Err(format!("wrong args for index_of: must be (string, string)").into())
}),
run: Arc::new(|a, _i| index_of(a, false)),
inner_statements: None,
})).add_var("index_of_rev".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -64,6 +68,7 @@ impl Config {
Err(format!("wrong args for index_of: must be (string, string)").into())
}),
run: Arc::new(|a, _i| index_of(a, true)),
inner_statements: None,
})).add_var("substring".to_string(), Data::new(data::function::Function {
info: Arc::new(Info::neverused()),
info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
@ -113,6 +118,7 @@ impl Config {
Data::new(data::string::String(s[start..end].to_owned()))
}),
inner_statements: None,
}))
}
}

6
mers_lib/src/program/parsed/as_type.rs
View File

@ -35,4 +35,10 @@ impl MersStatement for AsType {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.statement.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/parsed/assign_to.rs
View File

@ -31,4 +31,10 @@ impl MersStatement for AssignTo {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.source.as_ref(), self.target.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/parsed/block.rs
View File

@ -32,4 +32,10 @@ impl MersStatement for Block {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
self.statements.iter().map(|v| v.as_ref()).collect()
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/parsed/chain.rs
View File

@ -30,4 +30,10 @@ impl MersStatement for Chain {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.first.as_ref(), self.chained.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

10
mers_lib/src/program/parsed/custom_type.rs
View File

@ -37,6 +37,16 @@ impl MersStatement for CustomType {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
if let Err(s) = &self.source {
vec![s.as_ref()]
} else {
vec![]
}
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}
impl Debug for CustomType {

13
mers_lib/src/program/parsed/function.rs
View File

@ -29,8 +29,10 @@ impl MersStatement for Function {
let arg_target = Arc::new(self.arg.compile(info, comp)?);
comp.is_init = false;
let run = Arc::new(self.run.compile(info, comp)?);
let arg2: Arc<Box<dyn crate::program::run::MersStatement>> = Arc::clone(&arg_target);
let run2: Arc<Box<dyn crate::program::run::MersStatement>> = Arc::clone(&run);
let arg2 = Arc::clone(&arg_target);
let run2 = Arc::clone(&run);
let arg3 = Arc::clone(&arg_target);
let run3 = Arc::clone(&run);
Ok(Box::new(program::run::function::Function {
pos_in_src: self.pos_in_src.clone(),
func_no_info: data::function::Function {
@ -44,10 +46,17 @@ impl MersStatement for Function {
data::defs::assign(&arg, &arg_target.run(info));
run.run(info)
}),
inner_statements: Some((arg3, run3)),
},
}))
}
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.arg.as_ref(), self.run.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

14
mers_lib/src/program/parsed/if.rs
View File

@ -36,4 +36,18 @@ impl MersStatement for If {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
if let Some(on_false) = &self.on_false {
vec![
self.condition.as_ref(),
self.on_true.as_ref(),
on_false.as_ref(),
]
} else {
vec![self.condition.as_ref(), self.on_true.as_ref()]
}
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

7
mers_lib/src/program/parsed/include_mers.rs
View File

@ -58,6 +58,7 @@ impl MersStatement for IncludeMers {
info_check: Arc::new(Mutex::new(info::Info::neverused())),
out: Arc::new(move |_, i| compiled.check(&mut i.duplicate(), None)),
run: Arc::new(move |_, i| compiled2.run(&mut i.duplicate())),
inner_statements: None,
},
}),
as_part_of_include: Some(self.inner_src.clone()),
@ -66,4 +67,10 @@ impl MersStatement for IncludeMers {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/parsed/init_to.rs
View File

@ -37,4 +37,10 @@ impl MersStatement for InitTo {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.source.as_ref(), self.target.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

63
mers_lib/src/program/parsed/mod.rs
View File

@ -1,4 +1,8 @@
use std::{collections::HashMap, fmt::Debug};
use std::{
collections::HashMap,
fmt::Debug,
sync::{Arc, Mutex},
};
use crate::{
errors::{CheckError, SourceRange},
@ -44,21 +48,53 @@ pub trait MersStatement: Debug + Send + Sync {
info: &mut Info,
comp: CompInfo,
) -> Result<Box<dyn super::run::MersStatement>, CheckError> {
info.global.depth += 1;
if self.has_scope() {
info.create_scope();
}
let o = self.compile_custom(info, comp);
if info.global.enable_hooks {
// Hooks - keep in sync with run/mod.rs/compile() hooks section
{
// `save_info_at` hook
let mut save_info_at = info.global.save_info_at.try_lock().unwrap();
if !save_info_at.is_empty() {
let pos_start = self.source_range().start().pos();
let pos_end = self.source_range().end().pos();
let cloned_info = Arc::new(info.clone());
for (save_to, save_at, deepest_statement) in save_info_at.iter_mut() {
if info.global.depth >= *deepest_statement
&& pos_start <= *save_at
&& *save_at < pos_end
{
if info.global.depth > *deepest_statement {
*deepest_statement = info.global.depth;
save_to.clear();
}
save_to.push((
self.source_range(),
Arc::clone(&cloned_info),
o.as_ref().map(|_| ()).map_err(|e| e.clone()),
));
}
}
}
}
}
if self.has_scope() {
info.end_scope();
}
info.global.depth -= 1;
o
}
fn source_range(&self) -> SourceRange;
fn inner_statements(&self) -> Vec<&dyn MersStatement>;
fn as_any(&self) -> &dyn std::any::Any;
}
#[derive(Clone, Copy)]
pub struct CompInfo {
is_init: bool,
pub is_init: bool,
}
impl Default for CompInfo {
fn default() -> Self {
@ -70,13 +106,30 @@ pub type Info = info::Info<Local>;
#[derive(Default, Clone, Debug)]
pub struct Local {
vars: HashMap<String, (usize, usize)>,
vars_count: usize,
pub vars: HashMap<String, (usize, usize)>,
pub vars_count: usize,
}
#[derive(Clone, Debug, Default)]
pub struct LocalGlobalInfo {
pub depth: usize,
pub enable_hooks: bool,
/// ((results, byte_pos_in_src, deepest_statement))
/// you only have to set `byte_pos_in_src`. `deepest` is used internally.
/// These values should be initialized to `(vec![], _, 0)`, but `0` can be replaced by a minimum statement depth, i.e. `2` to exclude the outer scope (which has depth `1`).
pub save_info_at: Arc<
Mutex<
Vec<(
Vec<(SourceRange, Arc<Info>, Result<(), CheckError>)>,
usize,
usize,
)>,
>,
>,
}
impl info::Local for Local {
type VariableIdentifier = String;
type VariableData = (usize, usize);
type Global = ();
type Global = LocalGlobalInfo;
fn init_var(&mut self, id: Self::VariableIdentifier, value: Self::VariableData) {
self.vars_count += 1;
self.vars.insert(id, value);

6
mers_lib/src/program/parsed/object.rs
View File

@ -32,4 +32,10 @@ impl MersStatement for Object {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
self.elems.iter().map(|(_, s)| s.as_ref()).collect()
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/parsed/tuple.rs
View File

@ -32,4 +32,10 @@ impl MersStatement for Tuple {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
self.elems.iter().map(|v| v.as_ref()).collect()
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/parsed/value.rs
View File

@ -29,4 +29,10 @@ impl MersStatement for Value {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/parsed/variable.rs
View File

@ -59,4 +59,10 @@ impl MersStatement for Variable {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/as_type.rs
View File

@ -75,4 +75,10 @@ impl MersStatement for AsType {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.statement.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/assign_to.rs
View File

@ -83,4 +83,10 @@ impl MersStatement for AssignTo {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.target.as_ref(), self.source.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/block.rs
View File

@ -38,4 +38,10 @@ impl MersStatement for Block {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
self.statements.iter().map(|s| s.as_ref()).collect()
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/chain.rs
View File

@ -101,4 +101,10 @@ impl MersStatement for Chain {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![self.first.as_ref(), self.chained.as_ref()]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/custom_type.rs
View File

@ -54,6 +54,12 @@ impl MersStatement for CustomType {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}
impl Debug for CustomType {

10
mers_lib/src/program/run/function.rs
View File

@ -34,4 +34,14 @@ impl MersStatement for Function {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
if let Some((a, b)) = &self.func_no_info.inner_statements {
vec![a.as_ref().as_ref(), b.as_ref().as_ref()]
} else {
vec![]
}
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

14
mers_lib/src/program/run/if.rs
View File

@ -73,4 +73,18 @@ impl MersStatement for If {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
if let Some(on_false) = &self.on_false {
vec![
self.condition.as_ref(),
self.on_true.as_ref(),
on_false.as_ref(),
]
} else {
vec![self.condition.as_ref(), self.on_true.as_ref()]
}
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

64
mers_lib/src/program/run/mod.rs
View File

@ -1,7 +1,7 @@
use std::{
collections::HashMap,
fmt::Debug,
sync::{Arc, RwLock},
sync::{Arc, Mutex, RwLock},
};
use crate::{
@ -43,13 +43,50 @@ pub trait MersStatement: Debug + Send + Sync {
/// if true, local variables etc. will be contained inside their own scope.
fn has_scope(&self) -> bool;
fn check(&self, info: &mut CheckInfo, assign: Option<&Type>) -> Result<Type, CheckError> {
info.global.depth += 1;
if self.has_scope() {
info.create_scope();
}
let o = self.check_custom(info, assign);
if info.global.enable_hooks {
// Hooks - keep in sync with run/mod.rs/compile() hooks section
'hook_save_info_at: {
// `save_info_at` hook
let mut save_info_at = if let Ok(lock) = info.global.save_info_at.try_lock() {
lock
} else {
eprintln!(
"[HOOKS/save_info_at] couldn't acquire lock - result may be incomplete"
);
break 'hook_save_info_at;
};
if !save_info_at.is_empty() {
let pos_start = self.source_range().start().pos();
let pos_end = self.source_range().end().pos();
let cloned_info = Arc::new(info.clone());
for (save_to, save_at, deepest_statement) in save_info_at.iter_mut() {
if info.global.depth >= *deepest_statement
&& pos_start <= *save_at
&& *save_at < pos_end
{
if info.global.depth > *deepest_statement {
*deepest_statement = info.global.depth;
save_to.clear();
}
save_to.push((
self.source_range(),
Arc::clone(&cloned_info),
o.clone(),
));
}
}
}
}
}
if self.has_scope() {
info.end_scope();
}
info.global.depth -= 1;
o
}
fn run(&self, info: &mut Info) -> Data {
@ -63,6 +100,8 @@ pub trait MersStatement: Debug + Send + Sync {
o
}
fn source_range(&self) -> SourceRange;
fn inner_statements(&self) -> Vec<&dyn MersStatement>;
fn as_any(&self) -> &dyn std::any::Any;
}
pub type Info = info::Info<Local>;
@ -70,11 +109,11 @@ pub type CheckInfo = info::Info<CheckLocal>;
#[derive(Default, Clone, Debug)]
pub struct Local {
vars: Vec<Arc<RwLock<Data>>>,
pub vars: Vec<Arc<RwLock<Data>>>,
}
#[derive(Default, Clone)]
pub struct CheckLocal {
vars: Vec<Type>,
pub vars: Vec<Type>,
pub types: HashMap<
String,
Result<
@ -83,6 +122,23 @@ pub struct CheckLocal {
>,
>,
}
#[derive(Clone, Debug, Default)]
pub struct CheckLocalGlobalInfo {
pub depth: usize,
pub enable_hooks: bool,
/// ((results, byte_pos_in_src, deepest_statement))
/// you only have to set `byte_pos_in_src`. `deepest` is used internally.
/// These values should be initialized to `(vec![], _, 0)`, but `0` can be replaced by a minimum statement depth, i.e. `2` to exclude the outer scope (which has depth `1`).
pub save_info_at: Arc<
Mutex<
Vec<(
Vec<(SourceRange, Arc<CheckInfo>, Result<Type, CheckError>)>,
usize,
usize,
)>,
>,
>,
}
impl Debug for CheckLocal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "CheckLocal {:?}, {:?}", self.vars, self.types.keys())
@ -124,7 +180,7 @@ impl info::Local for Local {
impl info::Local for CheckLocal {
type VariableIdentifier = usize;
type VariableData = Type;
type Global = ();
type Global = CheckLocalGlobalInfo;
fn init_var(&mut self, id: Self::VariableIdentifier, value: Self::VariableData) {
while self.vars.len() <= id {
self.vars.push(Type::empty());

6
mers_lib/src/program/run/object.rs
View File

@ -133,4 +133,10 @@ impl MersStatement for Object {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
self.elems.iter().map(|(_, s)| s.as_ref()).collect()
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/tuple.rs
View File

@ -93,4 +93,10 @@ impl MersStatement for Tuple {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
self.elems.iter().map(|s| s.as_ref()).collect()
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/value.rs
View File

@ -31,4 +31,10 @@ impl MersStatement for Value {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}

6
mers_lib/src/program/run/variable.rs
View File

@ -79,4 +79,10 @@ impl MersStatement for Variable {
fn source_range(&self) -> SourceRange {
self.pos_in_src.clone()
}
fn inner_statements(&self) -> Vec<&dyn MersStatement> {
vec![]
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}