maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(users/tazjin): rustfmt code with non-default settings

Browse source 
rustfmt only sometimes detects path-based nested config
files (probably some kind of race?), so my users folder uses a
separate formatting check for rustfmt to avoid flaky CI. Enough flakes
around already ...

Change-Id: Ifd862f9974f071b3a256643dd8e56c019116156a
Reviewed-on: https://cl.tvl.fyi/c/depot/+/5242
Reviewed-by: tazjin <tazjin@tvl.su>
Autosubmit: tazjin <tazjin@tvl.su>
Tested-by: BuildkiteCI
This commit is contained in:
Vincent Ambo 2022-02-07 19:29:52 +03:00 • committed by clbot
parent 8b8c98380e
commit 0d0b43ed88
16 changed files with 348 additions and 421 deletions
Download patch file Download diff file Expand all files Collapse all files

89
users/tazjin/rlox/src/bytecode/compiler.rs
View file

@ -63,9 +63,11 @@ enum Precedence {
Equality, // == !=
Comparison, // < > <= >=
Term, // + -
Factor, // * /
Unary, // ! -
Call, // . ()
Factor, //
//
// * /
Unary, // ! -
Call, // . ()
Primary,
}
@ -78,11 +80,7 @@ struct ParseRule<T: Iterator<Item = Token>> {
}
impl<T: Iterator<Item = Token>> ParseRule<T> {
fn new(
prefix: Option<ParseFn<T>>,
infix: Option<ParseFn<T>>,
precedence: Precedence,
) -> Self {
fn new(prefix: Option<ParseFn<T>>, infix: Option<ParseFn<T>>, precedence: Precedence) -> Self {
ParseRule {
prefix,
infix,
@ -105,18 +103,16 @@ impl Precedence {
Precedence::Factor => Precedence::Unary,
Precedence::Unary => Precedence::Call,
Precedence::Call => Precedence::Primary,
Precedence::Primary => panic!(
"invalid parser state: no higher precedence than Primary"
),
Precedence::Primary => {
panic!("invalid parser state: no higher precedence than Primary")
}
}
}
}
fn rule_for<T: Iterator<Item = Token>>(token: &TokenKind) -> ParseRule<T> {
match token {
TokenKind::LeftParen => {
ParseRule::new(Some(Compiler::grouping), None, Precedence::None)
}
TokenKind::LeftParen => ParseRule::new(Some(Compiler::grouping), None, Precedence::None),
TokenKind::Minus => ParseRule::new(
Some(Compiler::unary),
@ -124,57 +120,33 @@ fn rule_for<T: Iterator<Item = Token>>(token: &TokenKind) -> ParseRule<T> {
Precedence::Term,
),
TokenKind::Plus => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Term)
}
TokenKind::Plus => ParseRule::new(None, Some(Compiler::binary), Precedence::Term),
TokenKind::Slash => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Factor)
}
TokenKind::Slash => ParseRule::new(None, Some(Compiler::binary), Precedence::Factor),
TokenKind::Star => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Factor)
}
TokenKind::Star => ParseRule::new(None, Some(Compiler::binary), Precedence::Factor),
TokenKind::Number(_) => {
ParseRule::new(Some(Compiler::number), None, Precedence::None)
}
TokenKind::Number(_) => ParseRule::new(Some(Compiler::number), None, Precedence::None),
TokenKind::True => {
ParseRule::new(Some(Compiler::literal), None, Precedence::None)
}
TokenKind::True => ParseRule::new(Some(Compiler::literal), None, Precedence::None),
TokenKind::False => {
ParseRule::new(Some(Compiler::literal), None, Precedence::None)
}
TokenKind::False => ParseRule::new(Some(Compiler::literal), None, Precedence::None),
TokenKind::Nil => {
ParseRule::new(Some(Compiler::literal), None, Precedence::None)
}
TokenKind::Nil => ParseRule::new(Some(Compiler::literal), None, Precedence::None),
TokenKind::Bang => {
ParseRule::new(Some(Compiler::unary), None, Precedence::None)
}
TokenKind::Bang => ParseRule::new(Some(Compiler::unary), None, Precedence::None),
TokenKind::BangEqual => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Equality)
}
TokenKind::BangEqual => ParseRule::new(None, Some(Compiler::binary), Precedence::Equality),
TokenKind::EqualEqual => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Equality)
}
TokenKind::EqualEqual => ParseRule::new(None, Some(Compiler::binary), Precedence::Equality),
TokenKind::Greater => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Comparison)
}
TokenKind::Greater => ParseRule::new(None, Some(Compiler::binary), Precedence::Comparison),
TokenKind::GreaterEqual => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Comparison)
}
TokenKind::Less => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Comparison)
}
TokenKind::Less => ParseRule::new(None, Some(Compiler::binary), Precedence::Comparison),
TokenKind::LessEqual => {
ParseRule::new(None, Some(Compiler::binary), Precedence::Comparison)
@ -184,9 +156,7 @@ fn rule_for<T: Iterator<Item = Token>>(token: &TokenKind) -> ParseRule<T> {
ParseRule::new(Some(Compiler::variable), None, Precedence::None)
}
TokenKind::String(_) => {
ParseRule::new(Some(Compiler::string), None, Precedence::None)
}
TokenKind::String(_) => ParseRule::new(Some(Compiler::string), None, Precedence::None),
_ => ParseRule::new(None, None, Precedence::None),
}
@ -236,9 +206,7 @@ impl<T: Iterator<Item = Token>> Compiler<T> {
fn define_variable(&mut self, var: Option<ConstantIdx>) -> LoxResult<()> {
if self.locals.scope_depth == 0 {
self.emit_op(OpCode::OpDefineGlobal(
var.expect("should be global"),
));
self.emit_op(OpCode::OpDefineGlobal(var.expect("should be global")));
} else {
self.locals
.locals
@ -305,9 +273,7 @@ impl<T: Iterator<Item = Token>> Compiler<T> {
}
fn block(&mut self) -> LoxResult<()> {
while !self.check(&TokenKind::RightBrace)
&& !self.check(&TokenKind::Eof)
{
while !self.check(&TokenKind::RightBrace) && !self.check(&TokenKind::Eof) {
self.declaration()?;
}
@ -712,9 +678,8 @@ impl<T: Iterator<Item = Token>> Compiler<T> {
pub fn compile(code: &str) -> Result<(Interner, Chunk), Vec<Error>> {
let chars = code.chars().collect::<Vec<char>>();
let tokens = scanner::scan(&chars).map_err(|errors| {
errors.into_iter().map(Into::into).collect::<Vec<Error>>()
})?;
let tokens = scanner::scan(&chars)
.map_err(|errors| errors.into_iter().map(Into::into).collect::<Vec<Error>>())?;
let mut compiler = Compiler {
tokens: tokens.into_iter().peekable(),

5
users/tazjin/rlox/src/bytecode/mod.rs
View file

@ -23,10 +23,7 @@ impl crate::Lox for Interpreter {
Interpreter {}
}
fn interpret(
&mut self,
code: String,
) -> Result<Self::Value, Vec<Self::Error>> {
fn interpret(&mut self, code: String) -> Result<Self::Value, Vec<Self::Error>> {
let (strings, chunk) = compiler::compile(&code)?;
vm::interpret(strings, chunk).map_err(|e| vec![e])
}

33
users/tazjin/rlox/src/bytecode/vm.rs
View file

@ -118,12 +118,7 @@ impl VM {
OpCode::OpNegate => {
let v = self.pop();
with_type!(
self,
v,
Value::Number(num),
self.push(Value::Number(-num))
);
with_type!(self, v, Value::Number(num), self.push(Value::Number(-num)));
}
OpCode::OpSubtract => binary_op!(self, Number, -),
@ -141,15 +136,18 @@ impl VM {
self.push(Value::String(new_s.into()));
}
(Value::Number(n_a), Value::Number(n_b)) =>
self.push(Value::Number(n_a + n_b)),
(Value::Number(n_a), Value::Number(n_b)) => {
self.push(Value::Number(n_a + n_b))
}
_ => return Err(Error {
line: self.chunk.get_line(self.ip - 1),
kind: ErrorKind::TypeError(
"'+' operator only works on strings and numbers".into()
),
})
_ => {
return Err(Error {
line: self.chunk.get_line(self.ip - 1),
kind: ErrorKind::TypeError(
"'+' operator only works on strings and numbers".into(),
),
})
}
}
}
@ -205,8 +203,7 @@ impl VM {
self.stack.len() > local_idx.0,
"stack is not currently large enough for local"
);
self.stack[local_idx.0] =
self.stack.last().unwrap().clone();
self.stack[local_idx.0] = self.stack.last().unwrap().clone();
}
OpCode::OpJumpPlaceholder(_) => {
@ -255,9 +252,7 @@ impl VM {
fn print_value(&self, val: Value) -> String {
match val {
Value::String(LoxString::Heap(s)) => s,
Value::String(LoxString::Interned(id)) => {
self.strings.lookup(id).into()
}
Value::String(LoxString::Interned(id)) => self.strings.lookup(id).into(),
_ => format!("{:?}", val),
}
}