waalge/aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix: constr issue

Browse Source 
- also fixed constant parsing
- added new cbor flag to eval

Co-authored-by: rvcas <x@rvcas.dev>
This commit is contained in:
Kasey White
2022-12-05 22:46:33 -05:00
committed by Lucas
parent 7875af7d35
commit 3f47a1f4b8
16 changed files with 155 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
crates/cli/src/cmd/uplc/eval.rs
View File

@@ -14,12 +14,31 @@ pub struct Args {
#[clap(short, long)]
flat: bool,
#[clap(short, long)]
cbor: bool,
/// Arguments to pass to the uplc program
args: Vec<String>,
}
pub fn exec(Args { script, flat, args }: Args) -> miette::Result<()> {
let mut program = if flat {
pub fn exec(
Args {
script,
flat,
args,
cbor,
}: Args,
) -> miette::Result<()> {
let mut program = if cbor {
let cbor_hex = std::fs::read_to_string(&script).into_diagnostic()?;
let raw_cbor = hex::decode(&cbor_hex).into_diagnostic()?;
let prog = Program::<FakeNamedDeBruijn>::from_cbor(&raw_cbor, &mut Vec::new())
.into_diagnostic()?;
prog.into()
} else if flat {
let bytes = std::fs::read(&script).into_diagnostic()?;
let prog = Program::<FakeNamedDeBruijn>::from_flat(&bytes).into_diagnostic()?;

3
crates/cli/src/lib.rs
View File

@@ -33,6 +33,7 @@ where
miette::bail!("failed: {} error(s), {warning_count} warning(s)", err.len(),);
};
println!("finished with {warning_count} warning(s)");
println!("\nfinished with {warning_count} warning(s)\n");
Ok(())
}

49
crates/lang/src/parser.rs
View File

@@ -306,10 +306,12 @@ fn constant_value_parser() -> impl Parser<Token, ast::UntypedConstant, Error = P
});
let constant_tuple_parser = just(Token::Hash)
.ignore_then(r.clone())
.separated_by(just(Token::Comma))
.allow_trailing()
.delimited_by(just(Token::LeftParen), just(Token::RightParen))
.ignore_then(
r.clone()
.separated_by(just(Token::Comma))
.allow_trailing()
.delimited_by(just(Token::LeftParen), just(Token::RightParen)),
)
.map_with_span(|elements, span| ast::UntypedConstant::Tuple {
location: span,
elements,
@@ -317,26 +319,27 @@ fn constant_value_parser() -> impl Parser<Token, ast::UntypedConstant, Error = P
let constant_bytearray_parser = just(Token::Hash)
.ignore_then(
select! {Token::Int {value} => value}.validate(|value, span, emit| {
let byte: u8 = match value.parse() {
Ok(b) => b,
Err(_) => {
emit(ParseError::expected_input_found(
span,
None,
Some(error::Pattern::Byte),
));
select! {Token::Int {value} => value}
.validate(|value, span, emit| {
let byte: u8 = match value.parse() {
Ok(b) => b,
Err(_) => {
emit(ParseError::expected_input_found(
span,
None,
Some(error::Pattern::Byte),
));
0
}
};
0
}
};
byte
}),
byte
})
.separated_by(just(Token::Comma))
.allow_trailing()
.delimited_by(just(Token::LeftSquare), just(Token::RightSquare)),
)
.separated_by(just(Token::Comma))
.allow_trailing()
.delimited_by(just(Token::LeftSquare), just(Token::RightSquare))
.map_with_span(|bytes, span| ast::UntypedConstant::ByteArray {
location: span,
bytes,
@@ -453,8 +456,8 @@ fn constant_value_parser() -> impl Parser<Token, ast::UntypedConstant, Error = P
choice((
constant_string_parser,
constant_int_parser,
constant_tuple_parser,
constant_bytearray_parser,
constant_tuple_parser,
constant_list_parser,
constant_record_parser,
constant_var_parser,
@@ -1271,6 +1274,7 @@ pub fn type_parser() -> impl Parser<Token, ast::Annotation, Error = ParseError>
.ignore_then(
r.clone()
.separated_by(just(Token::Comma))
.allow_trailing()
.delimited_by(just(Token::LeftParen), just(Token::RightParen)),
)
.map_with_span(|elems, span| ast::Annotation::Tuple {
@@ -1497,6 +1501,7 @@ pub fn pattern_parser() -> impl Parser<Token, ast::UntypedPattern, Error = Parse
.ignore_then(
r.clone()
.separated_by(just(Token::Comma))
.allow_trailing()
.delimited_by(just(Token::LeftParen), just(Token::RightParen)),
)
.map_with_span(|elems, span| ast::UntypedPattern::Tuple {

2
crates/lang/src/parser/lexer.rs
View File

@@ -30,8 +30,8 @@ pub fn lexer() -> impl Parser<char, Vec<(Token, Span)>, Error = ParseError> {
just("||").to(Token::VbarVbar),
just('|').to(Token::Vbar),
just("&&").to(Token::AmperAmper),
just("\n\n").to(Token::EmptyLine),
just('#').to(Token::Hash),
just("\n\n").to(Token::EmptyLine),
));
let grouping = choice((

2
crates/lang/src/tipo/error.rs
View File

@@ -215,7 +215,7 @@ pub enum Error {
types: Vec<String>,
},
#[error("Unknown variable\n\n{name}\n")]
#[error("Unknown variable\n\n {name}\n")]
UnknownVariable {
#[label]
location: Span,

111
crates/lang/src/uplc.rs
View File

@@ -5,11 +5,10 @@ use itertools::Itertools;
use uplc::{
ast::{
builder::{self, constr_index_exposer, CONSTR_FIELDS_EXPOSER, CONSTR_GET_FIELD},
Constant as UplcConstant, Name, Program, Term,
Constant as UplcConstant, Name, Program, Term, Type as UplcType,
},
builtins::DefaultFunction,
parser::interner::Interner,
BigInt, PlutusData,
};
use crate::{
@@ -166,11 +165,17 @@ impl<'a> CodeGenerator<'a> {
TypedExpr::Var {
constructor, name, ..
} => {
ir_stack.push(Air::Var {
scope,
constructor: constructor.clone(),
name: name.clone(),
});
if let ValueConstructorVariant::ModuleConstant { literal, .. } =
&constructor.variant
{
constants_ir(literal, ir_stack, scope);
} else {
ir_stack.push(Air::Var {
scope,
constructor: constructor.clone(),
name: name.clone(),
});
}
}
TypedExpr::Fn { .. } => todo!(),
TypedExpr::List {
@@ -1371,7 +1376,9 @@ impl<'a> CodeGenerator<'a> {
text: name,
unique: 0.into(),
})),
ValueConstructorVariant::ModuleConstant { .. } => todo!(),
ValueConstructorVariant::ModuleConstant { .. } => {
unreachable!()
}
ValueConstructorVariant::ModuleFn {
name: func_name,
module,
@@ -1420,25 +1427,78 @@ impl<'a> CodeGenerator<'a> {
.unwrap();
let mut fields =
Term::Constant(UplcConstant::Data(PlutusData::Array(vec![])));
Term::Constant(UplcConstant::ProtoList(UplcType::Data, vec![]));
let tipo = constructor.tipo;
let args_type = match tipo.as_ref() {
Type::Fn { args, .. } => args,
_ => todo!(),
};
if let Some(field_map) = field_map.clone() {
for field in field_map
.fields
.iter()
.sorted_by(|item1, item2| item1.1.cmp(item2.1))
.zip(args_type)
.rev()
{
let arg_to_data = if field.1.as_ref().is_bytearray() {
Term::Apply {
function: Term::Builtin(DefaultFunction::BData).into(),
argument: Term::Var(Name {
text: field.0 .0.clone(),
unique: 0.into(),
})
.into(),
}
} else if field.1.as_ref().is_int() {
Term::Apply {
function: Term::Builtin(DefaultFunction::IData).into(),
argument: Term::Var(Name {
text: field.0 .0.clone(),
unique: 0.into(),
})
.into(),
}
} else if field.1.as_ref().is_list() {
Term::Apply {
function: Term::Builtin(DefaultFunction::ListData).into(),
argument: Term::Var(Name {
text: field.0 .0.clone(),
unique: 0.into(),
})
.into(),
}
} else if field.1.as_ref().is_string() {
Term::Apply {
function: Term::Builtin(DefaultFunction::BData).into(),
argument: Term::Apply {
function: Term::Builtin(DefaultFunction::DecodeUtf8)
.into(),
argument: Term::Var(Name {
text: field.0 .0.clone(),
unique: 0.into(),
})
.into(),
}
.into(),
}
} else {
Term::Var(Name {
text: field.0 .0.clone(),
unique: 0.into(),
})
};
fields = Term::Apply {
function: Term::Apply {
function: Term::Builtin(DefaultFunction::MkCons)
.force_wrap()
.into(),
argument: Term::Var(Name {
text: field.0.clone(),
unique: 0.into(),
})
.into(),
argument: arg_to_data.into(),
}
.into(),
argument: fields.into(),
@@ -1447,25 +1507,15 @@ impl<'a> CodeGenerator<'a> {
}
let mut term = Term::Apply {
function: Term::Builtin(DefaultFunction::ConstrData).into(),
argument: Term::Apply {
function: Term::Apply {
function: Term::Builtin(DefaultFunction::MkPairData).into(),
argument: Term::Constant(UplcConstant::Data(
PlutusData::BigInt(BigInt::Int(
(constr_index as i128).try_into().unwrap(),
)),
))
.into(),
}
.into(),
argument: Term::Apply {
function: Term::Builtin(DefaultFunction::ListData).into(),
argument: fields.into(),
}
function: Term::Apply {
function: Term::Builtin(DefaultFunction::ConstrData).into(),
argument: Term::Constant(UplcConstant::Integer(
constr_index.try_into().unwrap(),
))
.into(),
}
.into(),
argument: fields.into(),
};
if let Some(field_map) = field_map {
@@ -2243,7 +2293,6 @@ impl<'a> CodeGenerator<'a> {
arg_stack.push(term);
}
Air::ListClause {
tail_name,
next_tail_name,