syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Fix clippyisms

This commit is contained in:
Tony Garnock-Jones 2019-10-20 13:57:04 +01:00
parent ccc3b5780b
commit 488bfdc59c
5 changed files with 67 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
implementations/rust/src/symbol.rs
View File

@ -12,7 +12,7 @@ impl serde::Serialize for Symbol {
impl<'de> serde::Deserialize<'de> for Symbol {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
let v = PlainValue::deserialize(deserializer)?;
let s = v.value().as_symbol().ok_or(serde::de::Error::custom("Expected symbol"))?;
let s = v.value().as_symbol().ok_or_else(|| serde::de::Error::custom("Expected symbol"))?;
Ok(Symbol(s.clone()))
}
}

29
implementations/rust/src/value/de.rs
View File

@ -54,10 +54,7 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
self.deserialize_unit(visitor)
} else if v.is_simple_record("UnicodeScalar", Some(1)) {
self.deserialize_char(visitor)
} else
if v.is_simple_record("None", Some(0)) ||
v.is_simple_record("Some", Some(1))
{
} else if v.is_simple_record("None", Some(0)) || v.is_simple_record("Some", Some(1)) {
self.deserialize_option(visitor)
} else if v.is_simple_record("tuple", None) {
visitor.visit_seq(VecSeq::new(self, v.as_simple_record("tuple", None).unwrap()))
@ -78,49 +75,49 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i8(i.to_i8().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_i8(i.to_i8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i16(i.to_i16().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_i16(i.to_i16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i32(i.to_i32().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_i32(i.to_i32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i64(i.to_i64().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_i64(i.to_i64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u8(i.to_u8().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_u8(i.to_u8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u16(i.to_u16().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_u16(i.to_u16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u32(i.to_u32().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_u32(i.to_u32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u64(i.to_u64().ok_or(Error::NumberTooLarge(i.clone()))?)
visitor.visit_u64(i.to_u64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
@ -269,12 +266,12 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
pub struct VecSeq<'a, 'de: 'a, N: NestedValue> {
index: usize,
vec: &'de Vec<N>,
vec: &'de [N],
de: &'a mut Deserializer<'de, N>,
}
impl<'de, 'a, N: NestedValue> VecSeq<'a, 'de, N> {
fn new(de: &'a mut Deserializer<'de, N>, vec: &'de Vec<N>) -> Self {
fn new(de: &'a mut Deserializer<'de, N>, vec: &'de [N]) -> Self {
VecSeq{ index: 0, vec, de }
}
}
@ -290,7 +287,7 @@ impl<'de, 'a, N: NestedValue> SeqAccess<'de> for VecSeq<'a, 'de, N> {
}
self.de.input = &self.vec[self.index];
self.index = self.index + 1;
self.index += 1;
let value = seed.deserialize(&mut *self.de)?;
Ok(Some(value))
}
@ -304,7 +301,7 @@ pub struct DictMap<'a, 'de: 'a, N: NestedValue> {
impl<'de, 'a, N: NestedValue> DictMap<'a, 'de, N> {
fn new(de: &'a mut Deserializer<'de, N>, d: &'de Map<N, N>) -> Self {
DictMap{ pending: None, iter: Box::new(d.into_iter()), de }
DictMap{ pending: None, iter: Box::new(d.iter()), de }
}
}

44
implementations/rust/src/value/decoder.rs
View File

@ -50,10 +50,17 @@ impl Error {
pub type DecodePlaceholderMap<N> = Map<usize, Value<N>>;
#[derive(PartialEq, Eq)]
enum PeekState {
Empty,
Eof,
Full(u8),
}
pub struct Decoder<'a, 'b, R: Read, N: NestedValue> {
read: &'a mut R,
index: usize,
buf: Box<Option<Option<u8>>>,
buf: Box<PeekState>,
placeholders: Option<&'b DecodePlaceholderMap<N>>,
read_annotations: bool,
}
@ -67,46 +74,47 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
Decoder{
read,
index: 0,
buf: Box::new(None),
buf: Box::new(PeekState::Empty),
placeholders,
read_annotations: true,
}
}
pub fn set_read_annotations(&mut self, read_annotations: bool) -> () {
pub fn set_read_annotations(&mut self, read_annotations: bool) {
self.read_annotations = read_annotations
}
fn prime(&mut self) -> Result<()> {
match *self.buf {
None => {
PeekState::Empty => {
let bs = &mut [0];
*self.buf = Some(match self.read.read(bs)? {
0 => None,
*self.buf = match self.read.read(bs)? {
0 => PeekState::Eof,
1 => {
self.index = self.index + 1;
Some(bs[0])
self.index += 1;
PeekState::Full(bs[0])
},
_ => panic!("buffer overrun")
})
}
}
Some(_) => ()
PeekState::Eof => (),
PeekState::Full(_) => (),
}
Ok(())
}
pub fn skip(&mut self) -> Result<()> {
self.prime()?;
*self.buf = None;
*self.buf = PeekState::Empty;
Ok(())
}
pub fn peek(&mut self) -> Result<u8> {
self.prime()?;
match *self.buf {
Some(Some(v)) => Ok(v),
Some(None) => Err(Error::Eof),
None => unreachable!()
PeekState::Full(v) => Ok(v),
PeekState::Eof => Err(Error::Eof),
PeekState::Empty => unreachable!()
}
}
@ -117,7 +125,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
}
pub fn readbytes(&mut self, n: usize) -> Result<Vec<u8>> {
if (*self.buf).is_some() {
if *self.buf != PeekState::Empty {
unreachable!();
}
let mut bs = vec![0; n];
@ -139,7 +147,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
let mut pieces: Vec<N> = Vec::with_capacity(count);
while count > 0 {
pieces.push(self.next()?);
count = count - 1;
count -= 1;
}
Ok(pieces)
}
@ -190,7 +198,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
pub fn decodecompound(minor: CompoundMinor, mut pieces: Vec<N>) -> Result<N> {
match minor {
CompoundMinor::Record =>
if pieces.len() == 0 {
if pieces.is_empty() {
Err(Error::Syntax("Too few elements in encoded record"))
} else {
let label = pieces.remove(0);
@ -257,7 +265,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
annotations.push(self.next()?);
}
let v = self.next()?;
assert!(v.annotations().len() == 0);
assert!(v.annotations().is_empty());
Ok(N::wrap_ann(annotations, v.value_owned()))
} else {
self.next()?;

12
implementations/rust/src/value/encoder.rs
View File

@ -99,19 +99,23 @@ impl<'a, 'b, W: Write, N: NestedValue> Encoder<'a, 'b, W, N> {
Value::Record((ref l, ref fs)) => {
self.write_header(Op::Compound(CompoundMinor::Record), fs.len() + 1)?;
self.write(N::boxunwrap(l))?;
Ok(for f in fs { self.write(f)?; })
for f in fs { self.write(f)?; }
Ok(())
}
Value::Sequence(ref vs) => {
self.write_header(Op::Compound(CompoundMinor::Sequence), vs.len())?;
Ok(for v in vs { self.write(v)?; })
for v in vs { self.write(v)?; }
Ok(())
}
Value::Set(ref vs) => {
self.write_header(Op::Compound(CompoundMinor::Set), vs.len())?;
Ok(for v in vs { self.write(v)?; })
for v in vs { self.write(v)?; }
Ok(())
}
Value::Dictionary(ref vs) => {
self.write_header(Op::Compound(CompoundMinor::Dictionary), vs.len() << 1)?;
Ok(for (k, v) in vs { self.write(k)?; self.write(v)?; })
for (k, v) in vs { self.write(k)?; self.write(v)?; }
Ok(())
}
}
}

38
implementations/rust/src/value/value.rs
View File

@ -92,8 +92,8 @@ impl Ord for Float {
fn cmp(&self, other: &Self) -> Ordering {
let mut a: u32 = self.0.to_bits();
let mut b: u32 = other.0.to_bits();
if a & 0x80000000 != 0 { a ^= 0x7fffffff; }
if b & 0x80000000 != 0 { b ^= 0x7fffffff; }
if a & 0x8000_0000 != 0 { a ^= 0x7fff_ffff; }
if b & 0x8000_0000 != 0 { b ^= 0x7fff_ffff; }
(a as i32).cmp(&(b as i32))
}
}
@ -126,7 +126,7 @@ impl Hash for Double {
impl PartialEq for Double {
fn eq(&self, other: &Self) -> bool {
return self.0.to_bits() == other.0.to_bits();
self.0.to_bits() == other.0.to_bits()
}
}
@ -134,8 +134,8 @@ impl Ord for Double {
fn cmp(&self, other: &Self) -> Ordering {
let mut a: u64 = self.0.to_bits();
let mut b: u64 = other.0.to_bits();
if a & 0x8000000000000000 != 0 { a ^= 0x7fffffffffffffff; }
if b & 0x8000000000000000 != 0 { b ^= 0x7fffffffffffffff; }
if a & 0x8000_0000_0000_0000 != 0 { a ^= 0x7fff_ffff_ffff_ffff; }
if b & 0x8000_0000_0000_0000 != 0 { b ^= 0x7fff_ffff_ffff_ffff; }
(a as i64).cmp(&(b as i64))
}
}
@ -153,14 +153,14 @@ impl<N: NestedValue> From<bool> for Value<N> { fn from(v: bool) -> Self { Value:
impl<N: NestedValue> From<f32> for Value<N> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
impl<N: NestedValue> From<f64> for Value<N> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
impl<N: NestedValue> From<u8> for Value<N> { fn from(v: u8) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<i8> for Value<N> { fn from(v: i8) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<u16> for Value<N> { fn from(v: u16) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<i16> for Value<N> { fn from(v: i16) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<u32> for Value<N> { fn from(v: u32) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<i32> for Value<N> { fn from(v: i32) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<u64> for Value<N> { fn from(v: u64) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<i64> for Value<N> { fn from(v: i64) -> Self { Value::from(v as i128) } }
impl<N: NestedValue> From<u8> for Value<N> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<i8> for Value<N> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<u16> for Value<N> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<i16> for Value<N> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<u32> for Value<N> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<i32> for Value<N> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<u64> for Value<N> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<i64> for Value<N> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue> From<u128> for Value<N> { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
impl<N: NestedValue> From<i128> for Value<N> { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
impl<N: NestedValue> From<BigInt> for Value<N> { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } }
@ -193,7 +193,7 @@ impl<N: NestedValue> Debug for Value<N> {
}
Value::Symbol(ref v) => {
// TODO: proper escaping!
if v.len() == 0 {
if v.is_empty() {
f.write_str("||")
} else {
write!(f, "{}", v)
@ -558,7 +558,7 @@ impl<N: NestedValue> serde::Serialize for Value<N> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
let mut buf: Vec<u8> = Vec::new();
crate::value::Encoder::new(&mut buf, None).write_value(self)
.or(Err(serde::ser::Error::custom("Internal error")))?;
.or_else(|_| Err(serde::ser::Error::custom("Internal error")))?;
ValueWrapper(buf).serialize(serializer)
}
}
@ -567,18 +567,18 @@ impl<'de, N: NestedValue> serde::Deserialize<'de> for Value<N> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
let v: N = crate::value::Decoder::new(&mut &buf[..], None).next()
.or(Err(serde::de::Error::custom("Internal error")))?;
.or_else(|_| Err(serde::de::Error::custom("Internal error")))?;
Ok(v.value_owned())
}
}
pub fn serialize_nested_value<'de, S, N>(v: &N, serializer: S) ->
pub fn serialize_nested_value<S, N>(v: &N, serializer: S) ->
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue
{
use serde::Serialize;
let mut buf: Vec<u8> = Vec::new();
crate::value::Encoder::new(&mut buf, None).write(v)
.or(Err(serde::ser::Error::custom("Internal error")))?;
.or_else(|_| Err(serde::ser::Error::custom("Internal error")))?;
ValueWrapper(buf).serialize(serializer)
}
@ -588,7 +588,7 @@ pub fn deserialize_nested_value<'de, D, N>(deserializer: D) ->
use serde::Deserialize;
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
crate::value::Decoder::new(&mut &buf[..], None).next()
.or(Err(serde::de::Error::custom("Internal error")))
.or_else(|_| Err(serde::de::Error::custom("Internal error")))
}
//---------------------------------------------------------------------------