AleoHQ/leo
1
1
Fork 0
mirror of https://github.com/AleoHQ/leo.git synced 2024-11-28 19:23:24 +03:00
Code Issues Packages Projects Releases Wiki Activity

fix some failing tests

Browse Source
This commit is contained in:
Protryon 2021-03-07 06:27:42 -08:00
parent f86e03f4b7
commit f5187fc872
9 changed files with 129 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
asg/src/const_value.rs
View File

@ -186,7 +186,7 @@ macro_rules! const_int_bimap {
impl ConstInt {
const_int_op!(raw_value, String, x, format!("{}", x));
const_int_map!(value_negate, x, x.checked_neg()?);
const_int_map!(value_negate, x, x.overflowing_neg().0);
const_int_map!(value_bit_negate, x, !x);
@ -267,18 +267,61 @@ impl ConstInt {
Type::Integer(self.get_int_type())
}
fn parse_signed(int_type: &IntegerType, raw: u128) -> Option<ConstInt> {
Some(match int_type {
IntegerType::I8 => ConstInt::I8(raw.try_into().ok()?),
IntegerType::I16 => ConstInt::I16(raw.try_into().ok()?),
IntegerType::I32 => ConstInt::I32(raw.try_into().ok()?),
IntegerType::I64 => ConstInt::I64(raw.try_into().ok()?),
IntegerType::I128 => ConstInt::I128(raw.try_into().ok()?),
_ => panic!("illegal type passed to parse_signed"),
})
}
pub fn parse(int_type: &IntegerType, value: &str, span: &Span) -> Result<ConstInt, AsgConvertError> {
let raw: u128 = value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?;
Ok(match int_type {
IntegerType::I8 => ConstInt::I8(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::I16 => ConstInt::I16(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::I32 => ConstInt::I32(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::I64 => ConstInt::I64(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::I128 => ConstInt::I128(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::U8 => ConstInt::U8(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::U16 => ConstInt::U16(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::U32 => ConstInt::U32(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::U64 => ConstInt::U64(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
IntegerType::U128 => ConstInt::U128(value.parse().map_err(|_| AsgConvertError::invalid_int(&value, span))?),
// IntegerType::I8 => ConstInt::I8(raw.try_into().map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?),
// IntegerType::I16 => ConstInt::I16(raw.try_into().map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?),
// IntegerType::I32 => ConstInt::I32(raw.try_into().map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?),
// IntegerType::I64 => ConstInt::I64(raw.try_into().map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?),
// IntegerType::I128 => ConstInt::I128(raw.try_into().map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?),
IntegerType::U8 => ConstInt::U8(
raw.try_into()
.map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?,
),
IntegerType::U16 => ConstInt::U16(
raw.try_into()
.map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?,
),
IntegerType::U32 => ConstInt::U32(
raw.try_into()
.map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?,
),
IntegerType::U64 => ConstInt::U64(
raw.try_into()
.map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?,
),
IntegerType::U128 => ConstInt::U128(
raw.try_into()
.map_err(|_| AsgConvertError::overflowed_const_int(&value, span))?,
),
signed_type => {
if let Some(parsed) = Self::parse_signed(signed_type, raw) {
parsed
} else if let Some(_parsed) = Self::parse_signed(signed_type, raw - 1) {
match int_type {
IntegerType::I8 => ConstInt::I8(raw as i8),
IntegerType::I16 => ConstInt::I16(raw as i16),
IntegerType::I32 => ConstInt::I32(raw as i32),
IntegerType::I64 => ConstInt::I64(raw as i64),
IntegerType::I128 => ConstInt::I128(raw as i128),
_ => panic!("illegal type passed to parse_signed"),
}
} else {
return Err(AsgConvertError::overflowed_const_int(&value, span));
}
}
})
}
}

8
asg/src/error/mod.rs
View File

@ -244,6 +244,14 @@ impl AsgConvertError {
Self::new_from_span(format!("failed to parse int value '{}'", value), span)
}
pub fn overflowed_const_int(value: &str, span: &Span) -> Self {
Self::new_from_span(format!("const int value is overflowed for type '{}'", value), span)
}
pub fn unsigned_negation(span: &Span) -> Self {
Self::new_from_span("cannot negate unsigned integer".to_string(), span)
}
pub fn immutable_assignment(name: &str, span: &Span) -> Self {
Self::new_from_span(format!("illegal assignment to immutable variable '{}'", name), span)
}

20
asg/src/expression/unary.rs
View File

@ -126,15 +126,25 @@ impl<'a> FromAst<'a, leo_ast::UnaryExpression> for UnaryExpression<'a> {
}
},
};
let expr = <&Expression<'a>>::from_ast(scope, &*value.inner, expected_type.map(Into::into))?;
if matches!(value.op, UnaryOperation::Negate) {
let is_expr_unsigned = expr
.get_type()
.map(|x| match x {
Type::Integer(x) => !x.is_signed(),
_ => false,
})
.unwrap_or(false);
if is_expr_unsigned {
return Err(AsgConvertError::unsigned_negation(&value.span));
}
}
Ok(UnaryExpression {
parent: Cell::new(None),
span: Some(value.span.clone()),
operation: value.op.clone(),
inner: Cell::new(<&Expression<'a>>::from_ast(
scope,
&*value.inner,
expected_type.map(Into::into),
)?),
inner: Cell::new(expr),
})
}
}

2
ast/src/common/span.rs
View File

@ -76,7 +76,7 @@ impl std::ops::Add for Span {
col_stop: self.col_stop.max(other.col_stop),
path: self.path,
}
} else if self.line_start < other.line_start {
} else if self.line_start < other.line_stop {
Span {
line_start: self.line_start,
line_stop: other.line_stop,

10
ast/src/types/integer_type.rs
View File

@ -39,6 +39,16 @@ pub enum IntegerType {
I128,
}
impl IntegerType {
pub fn is_signed(&self) -> bool {
use IntegerType::*;
match self {
I8 | I16 | I32 | I64 | I128 => true,
_ => false,
}
}
}
impl From<InputIntegerType> for IntegerType {
fn from(integer_type: InputIntegerType) -> Self {
match integer_type {

17
compiler/tests/mutability/mod.rs
View File

@ -33,23 +33,6 @@ fn test_let_mut() {
assert_satisfied(program);
}
#[test]
fn test_cond_mut() {
let program_string = r#"
function main() {
let mut x = 100i8;
if false {
x = 1i8;
x *= 100i8;
}
console.assert(x == 100);
}
"#;
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
}
#[test]
fn test_let_mut_nested() {
let program_string = include_str!("let_mut_nested.leo");

4
parser/src/tokenizer/lexer.rs
View File

@ -175,9 +175,7 @@ impl Token {
}
b',' => return (&input[1..], Some(Token::Comma)),
b'-' => {
if let (followed_int, Some(Token::Int(token))) = Self::gobble_int(&input[1..]) {
return (followed_int, Some(Token::Int(format!("-{}", token))));
} else if let Some(input) = eat(input, "->") {
if let Some(input) = eat(input, "->") {
return (input, Some(Token::Arrow));
} else if let Some(input) = eat(input, "-=") {
return (input, Some(Token::MinusEq));

2
parser/src/tokenizer/mod.rs
View File

@ -222,7 +222,7 @@ mod tests {
assert_eq!(
output,
r#""test" "test{}test" "test{}" "{}test" "test{" "test}" "test{test" "test}test" "te{{}}" aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8 test_ident 12345 address as bool circuit const else false field for function group i128 i64 i32 i16 i8 if import in input let mut return static string test true u128 u64 u32 u16 u8 self Self console ! != && ( ) * ** **= *= + += , - -= -> . .. ... / /= : :: ; < <= = == > >= @ [ ] { { } } || & &= | |= ^ ^= ~ << <<= >> >>= >>> >>>= % %= ||= &&= ? // test
/* test */ //
/* test */ //
"#
);
}

72
parser/tests/serialization/expected_leo_ast.json
View File

@ -1,14 +1,15 @@
{
"name": "leo_tree",
"name": "",
"expected_input": [],
"imports": [],
"circuits": {},
"functions": {
"{\"name\":\"main\",\"span\":\"{\\\"text\\\":\\\" function main() {\\\",\\\"line\\\":1,\\\"start\\\":10,\\\"end\\\":14}\"}": {
"identifier": "{\"name\":\"main\",\"span\":\"{\\\"text\\\":\\\" function main() {\\\",\\\"line\\\":1,\\\"start\\\":10,\\\"end\\\":14}\"}",
"{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"/home/p/aleo/leo/parser/tests/serialization/main.leo\\\"}\"}": {
"annotations": [],
"identifier": "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"/home/p/aleo/leo/parser/tests/serialization/main.leo\\\"}\"}",
"input": [],
"output": null,
"block" : {
"block": {
"statements": [
{
"Return": {
@ -19,59 +20,64 @@
"Implicit": [
"1",
{
"text": " return 1 + 1",
"line": 2,
"start": 12,
"end": 13
"line_start": 2,
"line_stop": 2,
"col_start": 12,
"col_stop": 13,
"path": "/home/p/aleo/leo/parser/tests/serialization/main.leo"
}
]
}
},
"op": "Add",
"right": {
"Value": {
"Implicit": [
"1",
{
"text": " return 1 + 1",
"line": 2,
"start": 16,
"end": 17
"line_start": 2,
"line_stop": 2,
"col_start": 16,
"col_stop": 17,
"path": "/home/p/aleo/leo/parser/tests/serialization/main.leo"
}
]
}
},
"op": "Add",
"span": {
"text": " return 1 + 1",
"line": 2,
"start": 12,
"end": 17
"line_start": 2,
"line_stop": 2,
"col_start": 12,
"col_stop": 17,
"path": "/home/p/aleo/leo/parser/tests/serialization/main.leo"
}
}
},
"span" : {
"text": " return 1 + 1",
"line": 2,
"start": 5,
"end": 17
"span": {
"line_start": 2,
"line_stop": 2,
"col_start": 5,
"col_stop": 17,
"path": "/home/p/aleo/leo/parser/tests/serialization/main.leo"
}
}
}
],
"span" : {
"text": " return 1 + 1",
"line": 2,
"start": 5,
"end": 17
"span": {
"line_start": 1,
"line_stop": 3,
"col_start": 17,
"col_stop": 2,
"path": "/home/p/aleo/leo/parser/tests/serialization/main.leo"
}
},
"span": {
"text": " function main() {",
"line": 1,
"start": 1,
"end": 1
"line_start": 1,
"line_stop": 3,
"col_start": 1,
"col_stop": 2,
"path": "/home/p/aleo/leo/parser/tests/serialization/main.leo"
}
}
},
"tests": {}
}
}