difftreelog
style fix clippy warnings
in: master
5 files changed
crates/jrsonnet-evaluator/src/ctx.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -38,7 +38,7 @@
#[derive(Debug, Clone)]
pub struct Context(Rc<ContextInternals>);
impl Context {
- pub fn new_future() -> FutureWrapper<Context> {
+ pub fn new_future() -> FutureWrapper<Self> {
FutureWrapper::new()
}
@@ -71,7 +71,7 @@
.cloned()
.ok_or(VariableIsNotDefined(name))?)
}
- pub fn into_future(self, ctx: FutureWrapper<Context>) -> Self {
+ pub fn into_future(self, ctx: FutureWrapper<Self>) -> Self {
{
ctx.0.borrow_mut().replace(self);
}
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -1,6 +1,6 @@
#![cfg_attr(feature = "unstable", feature(stmt_expr_attributes))]
-#![allow(macro_expanded_macro_exports_accessed_by_absolute_paths)]
#![warn(clippy::all, clippy::nursery)]
+#![allow(macro_expanded_macro_exports_accessed_by_absolute_paths, clippy::ptr_arg)]
mod builtin;
mod ctx;
@@ -429,7 +429,7 @@
}
pub fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {
- Ok(self.settings().import_resolver.resolve_file(from, path)?)
+ self.settings().import_resolver.resolve_file(from, path)
}
pub fn load_file_contents(&self, path: &PathBuf) -> Result<IStr> {
self.settings().import_resolver.load_file_contents(path)
crates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -173,7 +173,7 @@
pub fn extend_with_field(self, key: IStr, value: ObjMember) -> Self {
let mut new = FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());
new.insert(key, value);
- ObjValue::new(Some(self), Rc::new(new))
+ Self::new(Some(self), Rc::new(new))
}
pub(crate) fn get_raw(&self, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {
crates/jrsonnet-parser/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::redundant_closure_call)]
+
use peg::parser;
use std::{path::PathBuf, rc::Rc};
mod expr;
crates/jrsonnet-types/src/lib.rsdiffbeforeafterboth1use std::fmt::Display;23#[macro_export]4macro_rules! ty {5 ((Array<number>)) => {{6 $crate::ComplexValType::ArrayRef(&$crate::ComplexValType::Simple($crate::ValType::Num))7 }};8 (array) => {9 $crate::ComplexValType::Simple($crate::ValType::Arr)10 };11 (boolean) => {12 $crate::ComplexValType::Simple($crate::ValType::Bool)13 };14 (null) => {15 $crate::ComplexValType::Simple($crate::ValType::Null)16 };17 (string) => {18 $crate::ComplexValType::Simple($crate::ValType::Str)19 };20 (char) => {21 $crate::ComplexValType::Char22 };23 (number) => {24 $crate::ComplexValType::Simple($crate::ValType::Num)25 };26 (BoundedNumber<($min:expr), ($max:expr)>) => {{27 $crate::ComplexValType::BoundedNumber($min, $max)28 }};29 (object) => {30 $crate::ComplexValType::Simple($crate::ValType::Obj)31 };32 (any) => {33 $crate::ComplexValType::Any34 };35 (function) => {36 $crate::ComplexValType::Simple($crate::ValType::Func)37 };38 (($($a:tt) |+)) => {{39 static CONTENTS: &'static [$crate::ComplexValType] = &[40 $(ty!($a)),+41 ];42 $crate::ComplexValType::UnionRef(CONTENTS)43 }};44 (($($a:tt) &+)) => {{45 static CONTENTS: &'static [$crate::ComplexValType] = &[46 $(ty!($a)),+47 ];48 $crate::ComplexValType::SumRef(CONTENTS)49 }};50}5152#[test]53fn test() {54 assert_eq!(55 ty!((Array<number>)),56 ComplexValType::ArrayRef(&ComplexValType::Simple(ValType::Num))57 );58 assert_eq!(ty!(array), ComplexValType::Simple(ValType::Arr));59 assert_eq!(ty!(any), ComplexValType::Any);60 assert_eq!(61 ty!((string | number)),62 ComplexValType::UnionRef(&[63 ComplexValType::Simple(ValType::Str),64 ComplexValType::Simple(ValType::Num)65 ])66 );67 assert_eq!(68 format!("{}", ty!(((string & number) | (object & null)))),69 "string & number | object & null"70 );71 assert_eq!(format!("{}", ty!((string | array))), "string | array");72 assert_eq!(73 format!("{}", ty!(((string & number) | array))),74 "string & number | array"75 );76}7778#[derive(Debug, Clone, Copy, PartialEq, Eq)]79pub enum ValType {80 Bool,81 Null,82 Str,83 Num,84 Arr,85 Obj,86 Func,87}8889impl ValType {90 pub const fn name(&self) -> &'static str {91 use ValType::*;92 match self {93 Bool => "boolean",94 Null => "null",95 Str => "string",96 Num => "number",97 Arr => "array",98 Obj => "object",99 Func => "function",100 }101 }102}103104impl Display for ValType {105 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {106 write!(f, "{}", self.name())107 }108}109110#[derive(Debug, Clone, PartialEq)]111pub enum ComplexValType {112 Any,113 Char,114 Simple(ValType),115 BoundedNumber(Option<f64>, Option<f64>),116 Array(Box<ComplexValType>),117 ArrayRef(&'static ComplexValType),118 ObjectRef(&'static [(&'static str, ComplexValType)]),119 Union(Vec<ComplexValType>),120 UnionRef(&'static [ComplexValType]),121 Sum(Vec<ComplexValType>),122 SumRef(&'static [ComplexValType]),123}124impl From<ValType> for ComplexValType {125 fn from(s: ValType) -> Self {126 Self::Simple(s)127 }128}129130fn write_union(131 f: &mut std::fmt::Formatter<'_>,132 is_union: bool,133 union: &[ComplexValType],134) -> std::fmt::Result {135 for (i, v) in union.iter().enumerate() {136 let should_add_braces =137 matches!(v, ComplexValType::UnionRef(_) | ComplexValType::Union(_) if !is_union);138 if i != 0 {139 write!(f, " {} ", if is_union { '|' } else { '&' })?;140 }141 if should_add_braces {142 write!(f, "(")?;143 }144 write!(f, "{}", v)?;145 if should_add_braces {146 write!(f, ")")?;147 }148 }149 Ok(())150}151152fn print_array(a: &ComplexValType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {153 if *a == ComplexValType::Any {154 write!(f, "array")?155 } else {156 write!(f, "Array<{}>", a)?157 }158 Ok(())159}160161impl Display for ComplexValType {162 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {163 match self {164 ComplexValType::Any => write!(f, "any")?,165 ComplexValType::Simple(s) => write!(f, "{}", s)?,166 ComplexValType::Char => write!(f, "char")?,167 ComplexValType::BoundedNumber(a, b) => write!(168 f,169 "BoundedNumber<{}, {}>",170 a.map(|e| e.to_string()).unwrap_or_else(|| "".into()),171 b.map(|e| e.to_string()).unwrap_or_else(|| "".into())172 )?,173 ComplexValType::ArrayRef(a) => print_array(a, f)?,174 ComplexValType::Array(a) => print_array(a, f)?,175 ComplexValType::ObjectRef(fields) => {176 write!(f, "{{")?;177 for (i, (k, v)) in fields.iter().enumerate() {178 if i != 0 {179 write!(f, ", ")?;180 }181 write!(f, "{}: {}", k, v)?;182 }183 write!(f, "}}")?;184 }185 ComplexValType::Union(v) => write_union(f, true, v)?,186 ComplexValType::UnionRef(v) => write_union(f, true, v)?,187 ComplexValType::Sum(v) => write_union(f, false, v)?,188 ComplexValType::SumRef(v) => write_union(f, false, v)?,189 };190 Ok(())191 }192}193194peg::parser! {195pub grammar parser() for str {196 rule number() -> f64197 = n:$(['0'..='9']+) { n.parse().unwrap() }198199 rule any_ty() -> ComplexValType = "any" { ComplexValType::Any }200 rule char_ty() -> ComplexValType = "character" { ComplexValType::Char }201 rule bool_ty() -> ComplexValType = "boolean" { ComplexValType::Simple(ValType::Bool) }202 rule null_ty() -> ComplexValType = "null" { ComplexValType::Simple(ValType::Null) }203 rule str_ty() -> ComplexValType = "string" { ComplexValType::Simple(ValType::Str) }204 rule num_ty() -> ComplexValType = "number" { ComplexValType::Simple(ValType::Num) }205 rule simple_array_ty() -> ComplexValType = "array" { ComplexValType::Simple(ValType::Arr) }206 rule simple_object_ty() -> ComplexValType = "object" { ComplexValType::Simple(ValType::Obj) }207 rule simple_function_ty() -> ComplexValType = "function" { ComplexValType::Simple(ValType::Func) }208209 rule array_ty() -> ComplexValType210 = "Array<" t:ty() ">" { ComplexValType::Array(Box::new(t)) }211212 rule bounded_number_ty() -> ComplexValType213 = "BoundedNumber<" a:number() ", " b:number() ">" { ComplexValType::BoundedNumber(Some(a), Some(b)) }214215 rule ty_basic() -> ComplexValType216 = any_ty()217 / char_ty()218 / bool_ty()219 / null_ty()220 / str_ty()221 / num_ty()222 / simple_array_ty()223 / simple_object_ty()224 / simple_function_ty()225 / array_ty()226 / bounded_number_ty()227228 pub rule ty() -> ComplexValType229 = precedence! {230 a:(@) " | " b:@ {231 match a {232 ComplexValType::Union(mut a) => {233 a.push(b);234 ComplexValType::Union(a)235 }236 _ => ComplexValType::Union(vec![a, b]),237 }238 }239 --240 a:(@) " & " b:@ {241 match a {242 ComplexValType::Sum(mut a) => {243 a.push(b);244 ComplexValType::Sum(a)245 }246 _ => ComplexValType::Sum(vec![a, b]),247 }248 }249 --250 "(" t:ty() ")" { t }251 t:ty_basic() { t }252 }253}254}255256#[cfg(test)]257pub mod tests {258 use super::parser;259260 #[test]261 fn precedence() {262 assert_eq!(263 parser::ty("(any & any) | (any | any) & any")264 .unwrap()265 .to_string(),266 "any & any | (any | any) & any"267 );268 }269270 #[test]271 fn array() {272 assert_eq!(parser::ty("Array<any>").unwrap().to_string(), "array");273 assert_eq!(274 parser::ty("Array<number>").unwrap().to_string(),275 "Array<number>"276 );277 }278 #[test]279 fn bounded_number() {280 assert_eq!(281 parser::ty("BoundedNumber<1, 2>").unwrap().to_string(),282 "BoundedNumber<1, 2>"283 );284 }285}1#![allow(clippy::redundant_closure_call)]23use std::fmt::Display;45#[macro_export]6macro_rules! ty {7 ((Array<number>)) => {{8 $crate::ComplexValType::ArrayRef(&$crate::ComplexValType::Simple($crate::ValType::Num))9 }};10 (array) => {11 $crate::ComplexValType::Simple($crate::ValType::Arr)12 };13 (boolean) => {14 $crate::ComplexValType::Simple($crate::ValType::Bool)15 };16 (null) => {17 $crate::ComplexValType::Simple($crate::ValType::Null)18 };19 (string) => {20 $crate::ComplexValType::Simple($crate::ValType::Str)21 };22 (char) => {23 $crate::ComplexValType::Char24 };25 (number) => {26 $crate::ComplexValType::Simple($crate::ValType::Num)27 };28 (BoundedNumber<($min:expr), ($max:expr)>) => {{29 $crate::ComplexValType::BoundedNumber($min, $max)30 }};31 (object) => {32 $crate::ComplexValType::Simple($crate::ValType::Obj)33 };34 (any) => {35 $crate::ComplexValType::Any36 };37 (function) => {38 $crate::ComplexValType::Simple($crate::ValType::Func)39 };40 (($($a:tt) |+)) => {{41 static CONTENTS: &'static [$crate::ComplexValType] = &[42 $(ty!($a)),+43 ];44 $crate::ComplexValType::UnionRef(CONTENTS)45 }};46 (($($a:tt) &+)) => {{47 static CONTENTS: &'static [$crate::ComplexValType] = &[48 $(ty!($a)),+49 ];50 $crate::ComplexValType::SumRef(CONTENTS)51 }};52}5354#[test]55fn test() {56 assert_eq!(57 ty!((Array<number>)),58 ComplexValType::ArrayRef(&ComplexValType::Simple(ValType::Num))59 );60 assert_eq!(ty!(array), ComplexValType::Simple(ValType::Arr));61 assert_eq!(ty!(any), ComplexValType::Any);62 assert_eq!(63 ty!((string | number)),64 ComplexValType::UnionRef(&[65 ComplexValType::Simple(ValType::Str),66 ComplexValType::Simple(ValType::Num)67 ])68 );69 assert_eq!(70 format!("{}", ty!(((string & number) | (object & null)))),71 "string & number | object & null"72 );73 assert_eq!(format!("{}", ty!((string | array))), "string | array");74 assert_eq!(75 format!("{}", ty!(((string & number) | array))),76 "string & number | array"77 );78}7980#[derive(Debug, Clone, Copy, PartialEq, Eq)]81pub enum ValType {82 Bool,83 Null,84 Str,85 Num,86 Arr,87 Obj,88 Func,89}9091impl ValType {92 pub const fn name(&self) -> &'static str {93 use ValType::*;94 match self {95 Bool => "boolean",96 Null => "null",97 Str => "string",98 Num => "number",99 Arr => "array",100 Obj => "object",101 Func => "function",102 }103 }104}105106impl Display for ValType {107 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {108 write!(f, "{}", self.name())109 }110}111112#[derive(Debug, Clone, PartialEq)]113pub enum ComplexValType {114 Any,115 Char,116 Simple(ValType),117 BoundedNumber(Option<f64>, Option<f64>),118 Array(Box<ComplexValType>),119 ArrayRef(&'static ComplexValType),120 ObjectRef(&'static [(&'static str, ComplexValType)]),121 Union(Vec<ComplexValType>),122 UnionRef(&'static [ComplexValType]),123 Sum(Vec<ComplexValType>),124 SumRef(&'static [ComplexValType]),125}126impl From<ValType> for ComplexValType {127 fn from(s: ValType) -> Self {128 Self::Simple(s)129 }130}131132fn write_union(133 f: &mut std::fmt::Formatter<'_>,134 is_union: bool,135 union: &[ComplexValType],136) -> std::fmt::Result {137 for (i, v) in union.iter().enumerate() {138 let should_add_braces =139 matches!(v, ComplexValType::UnionRef(_) | ComplexValType::Union(_) if !is_union);140 if i != 0 {141 write!(f, " {} ", if is_union { '|' } else { '&' })?;142 }143 if should_add_braces {144 write!(f, "(")?;145 }146 write!(f, "{}", v)?;147 if should_add_braces {148 write!(f, ")")?;149 }150 }151 Ok(())152}153154fn print_array(a: &ComplexValType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {155 if *a == ComplexValType::Any {156 write!(f, "array")?157 } else {158 write!(f, "Array<{}>", a)?159 }160 Ok(())161}162163impl Display for ComplexValType {164 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {165 match self {166 ComplexValType::Any => write!(f, "any")?,167 ComplexValType::Simple(s) => write!(f, "{}", s)?,168 ComplexValType::Char => write!(f, "char")?,169 ComplexValType::BoundedNumber(a, b) => write!(170 f,171 "BoundedNumber<{}, {}>",172 a.map(|e| e.to_string()).unwrap_or_else(|| "".into()),173 b.map(|e| e.to_string()).unwrap_or_else(|| "".into())174 )?,175 ComplexValType::ArrayRef(a) => print_array(a, f)?,176 ComplexValType::Array(a) => print_array(a, f)?,177 ComplexValType::ObjectRef(fields) => {178 write!(f, "{{")?;179 for (i, (k, v)) in fields.iter().enumerate() {180 if i != 0 {181 write!(f, ", ")?;182 }183 write!(f, "{}: {}", k, v)?;184 }185 write!(f, "}}")?;186 }187 ComplexValType::Union(v) => write_union(f, true, v)?,188 ComplexValType::UnionRef(v) => write_union(f, true, v)?,189 ComplexValType::Sum(v) => write_union(f, false, v)?,190 ComplexValType::SumRef(v) => write_union(f, false, v)?,191 };192 Ok(())193 }194}195196peg::parser! {197pub grammar parser() for str {198 rule number() -> f64199 = n:$(['0'..='9']+) { n.parse().unwrap() }200201 rule any_ty() -> ComplexValType = "any" { ComplexValType::Any }202 rule char_ty() -> ComplexValType = "character" { ComplexValType::Char }203 rule bool_ty() -> ComplexValType = "boolean" { ComplexValType::Simple(ValType::Bool) }204 rule null_ty() -> ComplexValType = "null" { ComplexValType::Simple(ValType::Null) }205 rule str_ty() -> ComplexValType = "string" { ComplexValType::Simple(ValType::Str) }206 rule num_ty() -> ComplexValType = "number" { ComplexValType::Simple(ValType::Num) }207 rule simple_array_ty() -> ComplexValType = "array" { ComplexValType::Simple(ValType::Arr) }208 rule simple_object_ty() -> ComplexValType = "object" { ComplexValType::Simple(ValType::Obj) }209 rule simple_function_ty() -> ComplexValType = "function" { ComplexValType::Simple(ValType::Func) }210211 rule array_ty() -> ComplexValType212 = "Array<" t:ty() ">" { ComplexValType::Array(Box::new(t)) }213214 rule bounded_number_ty() -> ComplexValType215 = "BoundedNumber<" a:number() ", " b:number() ">" { ComplexValType::BoundedNumber(Some(a), Some(b)) }216217 rule ty_basic() -> ComplexValType218 = any_ty()219 / char_ty()220 / bool_ty()221 / null_ty()222 / str_ty()223 / num_ty()224 / simple_array_ty()225 / simple_object_ty()226 / simple_function_ty()227 / array_ty()228 / bounded_number_ty()229230 pub rule ty() -> ComplexValType231 = precedence! {232 a:(@) " | " b:@ {233 match a {234 ComplexValType::Union(mut a) => {235 a.push(b);236 ComplexValType::Union(a)237 }238 _ => ComplexValType::Union(vec![a, b]),239 }240 }241 --242 a:(@) " & " b:@ {243 match a {244 ComplexValType::Sum(mut a) => {245 a.push(b);246 ComplexValType::Sum(a)247 }248 _ => ComplexValType::Sum(vec![a, b]),249 }250 }251 --252 "(" t:ty() ")" { t }253 t:ty_basic() { t }254 }255}256}257258#[cfg(test)]259pub mod tests {260 use super::parser;261262 #[test]263 fn precedence() {264 assert_eq!(265 parser::ty("(any & any) | (any | any) & any")266 .unwrap()267 .to_string(),268 "any & any | (any | any) & any"269 );270 }271272 #[test]273 fn array() {274 assert_eq!(parser::ty("Array<any>").unwrap().to_string(), "array");275 assert_eq!(276 parser::ty("Array<number>").unwrap().to_string(),277 "Array<number>"278 );279 }280 #[test]281 fn bounded_number() {282 assert_eq!(283 parser::ty("BoundedNumber<1, 2>").unwrap().to_string(),284 "BoundedNumber<1, 2>"285 );286 }287}