greg/schala
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Clippy on schala-repl

Browse Source
This commit is contained in:
Greg Shuflin 2021-10-14 02:08:32 -07:00
parent 5dcfce46cc
commit 6ac0628265
6 changed files with 22 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
schala-repl/src/command_tree.rs
View File

@ -89,7 +89,7 @@ impl CommandTree {
pub fn perform<L: ProgrammingLanguageInterface>(
&self,
repl: &mut Repl<L>,
arguments: &Vec<&str>,
arguments: &[&str],
) -> InterpreterDirectiveOutput {
let mut dir_pointer: &CommandTree = self;
let mut idx = 0;
@ -103,7 +103,7 @@ impl CommandTree {
} => {
let next_command = match arguments.get(idx) {
Some(cmd) => cmd,
None => break Err(format!("Command requires arguments")),
None => break Err("Command requires arguments".to_owned()),
};
idx += 1;
match subcommands.iter().find(|sc| sc.get_cmd() == *next_command) {

65
schala-repl/src/directive_actions.rs
View File

@ -1,6 +1,6 @@
use crate::help::help;
use crate::language::{
DebugAsk, DebugResponse, LangMetaRequest, LangMetaResponse, ProgrammingLanguageInterface,
LangMetaRequest, LangMetaResponse, ProgrammingLanguageInterface,
};
use crate::{InterpreterDirectiveOutput, Repl};
use std::fmt::Write as FmtWrite;
@ -11,9 +11,6 @@ pub enum DirectiveAction {
Help,
QuitProgram,
ListPasses,
ShowImmediate,
Show,
Hide,
TotalTimeOff,
TotalTimeOn,
StageTimeOff,
@ -45,7 +42,7 @@ impl DirectiveAction {
};
let mut buf = String::new();
for pass in pass_names.iter().map(|name| Some(name)).intersperse(None) {
for pass in pass_names.iter().map(Some).intersperse(None) {
match pass {
Some(pass) => write!(buf, "{}", pass).unwrap(),
None => write!(buf, " -> ").unwrap(),
@ -53,60 +50,6 @@ impl DirectiveAction {
}
Some(buf)
}
ShowImmediate => {
let stage_name = match arguments.get(0) {
Some(s) => s.to_string(),
None => return Some(format!("Must specify a thing to debug")),
};
let meta = LangMetaRequest::ImmediateDebug(DebugAsk::ByStage {
stage_name: stage_name.clone(),
token: None,
});
let meta_response = repl.language_state.request_meta(meta);
let response = match meta_response {
LangMetaResponse::ImmediateDebug(DebugResponse { ask, value }) => match ask {
DebugAsk::ByStage {
stage_name: ref this_stage_name,
..
} if *this_stage_name == stage_name => value,
_ => return Some(format!("Wrong debug stage")),
},
_ => return Some(format!("Invalid language meta response")),
};
Some(response)
}
Show => {
let this_stage_name = match arguments.get(0) {
Some(s) => s.to_string(),
None => return Some(format!("Must specify a stage to show")),
};
let token = arguments.get(1).map(|s| s.to_string());
repl.options.debug_asks.retain(|ask| match ask {
DebugAsk::ByStage { stage_name, .. } if *stage_name == this_stage_name => false,
_ => true,
});
let ask = DebugAsk::ByStage {
stage_name: this_stage_name,
token,
};
repl.options.debug_asks.insert(ask);
None
}
Hide => {
let stage_name_to_remove = match arguments.get(0) {
Some(s) => s.to_string(),
None => return Some(format!("Must specify a stage to hide")),
};
repl.options.debug_asks.retain(|ask| match ask {
DebugAsk::ByStage { stage_name, .. } if *stage_name == stage_name_to_remove => {
false
}
_ => true,
});
None
}
TotalTimeOff => {
repl.options.show_total_time = false;
None
@ -139,8 +82,8 @@ fn doc<L: ProgrammingLanguageInterface>(
let meta = LangMetaRequest::Docs { source };
match repl.language_state.request_meta(meta) {
LangMetaResponse::Docs { doc_string } => Some(doc_string),
_ => Some(format!("Invalid doc response")),
_ => Some("Invalid doc response".to_owned()),
}
})
.unwrap_or(Some(format!(":docs needs an argument")))
.unwrap_or_else(|| Some(":docs needs an argument".to_owned()))
}

22
schala-repl/src/directives.rs
View File

@ -1,7 +1,7 @@
use crate::command_tree::CommandTree;
use crate::directive_actions::DirectiveAction;
pub fn directives_from_pass_names(pass_names: &Vec<String>) -> CommandTree {
pub fn directives_from_pass_names(pass_names: &[String]) -> CommandTree {
let passes_directives: Vec<CommandTree> = pass_names
.iter()
.map(|pass_name| {
@ -23,7 +23,7 @@ pub fn directives_from_pass_names(pass_names: &Vec<String>) -> CommandTree {
CommandTree::Top(get_list(&passes_directives, true))
}
fn get_list(passes_directives: &Vec<CommandTree>, include_help: bool) -> Vec<CommandTree> {
fn get_list(passes_directives: &[CommandTree], include_help: bool) -> Vec<CommandTree> {
use DirectiveAction::*;
vec![
@ -50,24 +50,6 @@ fn get_list(passes_directives: &Vec<CommandTree>, include_help: bool) -> Vec<Com
vec![],
ListPasses,
),
CommandTree::terminal(
"show-immediate",
None,
passes_directives.clone(),
ShowImmediate,
),
CommandTree::terminal(
"show",
Some("Show debug output for a specific pass"),
passes_directives.clone(),
Show,
),
CommandTree::terminal(
"hide",
Some("Hide debug output for a specific pass"),
passes_directives.clone(),
Hide,
),
CommandTree::nonterm(
"total-time",
None,

4
schala-repl/src/help.rs
View File

@ -10,7 +10,7 @@ pub fn help<L: ProgrammingLanguageInterface>(
arguments: &[&str],
) -> InterpreterDirectiveOutput {
match arguments {
[] => return global_help(repl),
[] => global_help(repl),
commands => {
let dirs = repl.get_directives();
Some(match get_directive_from_commands(commands, &dirs) {
@ -73,7 +73,7 @@ fn global_help<L: ProgrammingLanguageInterface>(repl: &mut Repl<L>) -> Interpret
.unwrap();
}
writeln!(buf, "").unwrap();
writeln!(buf).unwrap();
writeln!(
buf,
"Language-specific help for {}",

11
schala-repl/src/language.rs
View File

@ -10,7 +10,7 @@ pub trait ProgrammingLanguageInterface {
fn request_meta(&mut self, _request: LangMetaRequest) -> LangMetaResponse {
LangMetaResponse::Custom {
kind: format!("not-implemented"),
kind: "not-implemented".to_owned(),
value: format!(""),
}
}
@ -50,15 +50,6 @@ pub enum DebugAsk {
},
}
impl DebugAsk {
pub fn is_for_stage(&self, name: &str) -> bool {
match self {
DebugAsk::ByStage { stage_name, .. } if stage_name == name => true,
_ => false,
}
}
}
pub struct DebugResponse {
pub ask: DebugAsk,
pub value: String,

26
schala-repl/src/lib.rs
View File

@ -29,10 +29,10 @@ pub use language::{
};
include!(concat!(env!("OUT_DIR"), "/static.rs"));
const VERSION_STRING: &'static str = "0.1.0";
const VERSION_STRING: &str = "0.1.0";
const HISTORY_SAVE_FILE: &'static str = ".schala_history";
const OPTIONS_SAVE_FILE: &'static str = ".schala_repl";
const HISTORY_SAVE_FILE: &str = ".schala_history";
const OPTIONS_SAVE_FILE: &str = ".schala_repl";
type InterpreterDirectiveOutput = Option<String>;
@ -112,7 +112,7 @@ impl<L: ProgrammingLanguageInterface> Repl<L> {
self.line_reader.add_history_unique(input.to_string());
let mut chars = input.chars().peekable();
let repl_responses = match chars.nth(0) {
let repl_responses = match chars.next() {
Some(ch) if ch == self.sigil => {
if chars.peek() == Some(&'{') {
let mut buf = String::new();
@ -125,14 +125,13 @@ impl<L: ProgrammingLanguageInterface> Repl<L> {
break 'multiline;
} else {
buf.push_str(new_input);
buf.push_str("\n");
buf.push('\n');
}
}
self.handle_input(&buf)
} else {
match self.handle_interpreter_directive(input.get(1..).unwrap()) {
Some(directive_output) => println!("{}", directive_output),
None => (),
if let Some(output) = self.handle_interpreter_directive(input.get(1..).unwrap()) {
println!("{}", output);
}
continue;
}
@ -159,7 +158,7 @@ impl<L: ProgrammingLanguageInterface> Repl<L> {
PromptStyle::Multiline => ">| ",
};
self.line_reader.set_prompt(&prompt_str).unwrap();
self.line_reader.set_prompt(prompt_str).unwrap();
}
fn save_before_exit(&self) {
@ -172,7 +171,7 @@ impl<L: ProgrammingLanguageInterface> Repl<L> {
fn handle_interpreter_directive(&mut self, input: &str) -> InterpreterDirectiveOutput {
let arguments: Vec<&str> = input.split_whitespace().collect();
if arguments.len() < 1 {
if arguments.is_empty() {
return None;
}
@ -245,14 +244,11 @@ impl<T: Terminal> Completer<T> for TabCompleteHandler {
loop {
match words.next() {
None => {
let top = match command_tree {
Some(CommandTree::Top(_)) => true,
_ => false,
};
let top = matches!(command_tree, Some(CommandTree::Top(_)));
let word = if top { word.get(1..).unwrap() } else { word };
for cmd in command_tree
.map(|x| x.get_subcommands())
.unwrap_or(vec![])
.unwrap_or_default()
.into_iter()
{
if cmd.starts_with(word) {