acw/ngr
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Remove IR TopLevel.

Browse Source
This commit is contained in:
Adam Wick
2024-06-03 20:38:45 -07:00
parent 88d128df9f
commit cf7eff7a93
3 changed files with 31 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
src/ir/arbitrary.rs
View File

@@ -1,7 +1,5 @@
use crate::eval::PrimitiveType;
use crate::ir::{
Expression, Name, Primitive, Program, TopLevel, Type, TypeWithVoid, Value, ValueOrRef,
};
use crate::ir::{Expression, Name, Primitive, Program, Type, TypeWithVoid, Value, ValueOrRef};
use crate::syntax::Location;
use crate::util::scoped_map::ScopedMap;
use proptest::strategy::{NewTree, Strategy, ValueTree};
@@ -183,37 +181,37 @@ pub struct ProgramTree {
impl ProgramTree {
fn new(mut rng: TestRng) -> Self {
let mut items = vec![];
// let mut items = vec![];
let program_length = PROGRAM_LENGTH_DISTRIBUTION.sample(&mut rng);
let mut env = ScopedMap::new();
// let mut env = ScopedMap::new();
for _ in 0..program_length {
match STATEMENT_TYPE_FREQUENCIES[STATEMENT_TYPE_DISTRIBUTION.sample(&mut rng)].0 {
StatementType::Binding => {
let binding = generate_random_binding(&mut rng, &mut env);
items.push(TopLevel::Statement(binding));
}
StatementType::Expression => {
let expr = generate_random_expression(&mut rng, &mut env);
items.push(TopLevel::Statement(expr));
}
StatementType::Function => {
env.new_scope();
let name = generate_random_name(&mut rng);
let mut args = vec![];
let arg_count = FUNCTION_ARGUMENTS_DISTRIBUTION.sample(&mut rng);
for _ in 0..arg_count {
let name = generate_random_name(&mut rng);
let ty = generate_random_argument_type(&mut rng);
args.push((name, ty));
}
let body = generate_random_expression(&mut rng, &mut env);
let rettype = body.type_of();
env.release_scope();
items.push(TopLevel::Function(name, args, rettype, body))
}
}
}
// for _ in 0..program_length {
// match STATEMENT_TYPE_FREQUENCIES[STATEMENT_TYPE_DISTRIBUTION.sample(&mut rng)].0 {
// StatementType::Binding => {
// let binding = generate_random_binding(&mut rng, &mut env);
// items.push(TopLevel::Statement(binding));
// }
// StatementType::Expression => {
// let expr = generate_random_expression(&mut rng, &mut env);
// items.push(TopLevel::Statement(expr));
// }
// StatementType::Function => {
// env.new_scope();
// let name = generate_random_name(&mut rng);
// let mut args = vec![];
// let arg_count = FUNCTION_ARGUMENTS_DISTRIBUTION.sample(&mut rng);
// for _ in 0..arg_count {
// let name = generate_random_name(&mut rng);
// let ty = generate_random_argument_type(&mut rng);
// args.push((name, ty));
// }
// let body = generate_random_expression(&mut rng, &mut env);
// let rettype = body.type_of();
// env.release_scope();
// items.push(TopLevel::Function(name, args, rettype, body))
// }
// }
// }
let current = Program {
functions: HashMap::new(),

28
src/ir/ast.rs
View File

@@ -52,32 +52,6 @@ impl Arbitrary for Program<Type> {
}
}
/// A thing that can sit at the top level of a file.
///
/// For the moment, these are statements and functions. Other things
/// will likely be added in the future, but for now: just statements
/// and functions
#[derive(Clone, Debug)]
pub enum TopLevel<Type> {
Statement(Expression<Type>),
// FIXME: Is the return type actually necessary, given we can infer it from
// the expression type?
Function(Name, Vec<(Name, Type)>, Type, Expression<Type>),
}
impl<T: Clone + TypeWithVoid + TypeWithFunction> TopLevel<T> {
/// Return the type of the item, as inferred or recently
/// computed.
pub fn type_of(&self) -> T {
match self {
TopLevel::Statement(expr) => expr.type_of(),
TopLevel::Function(_, args, ret, _) => {
T::build_function_type(args.iter().map(|(_, t)| t.clone()).collect(), ret.clone())
}
}
}
}
/// The representation of an expression.
///
/// Note that expressions, like everything else in this syntax tree,
@@ -479,8 +453,6 @@ fn struct_sizes_are_rational() {
assert_eq!(80, std::mem::size_of::<ValueOrRef<TypeOrVar>>());
assert_eq!(200, std::mem::size_of::<Expression<Type>>());
assert_eq!(200, std::mem::size_of::<Expression<TypeOrVar>>());
assert_eq!(272, std::mem::size_of::<TopLevel<Type>>());
assert_eq!(272, std::mem::size_of::<TopLevel<TypeOrVar>>());
assert_eq!(72, std::mem::size_of::<Program<Type>>());
assert_eq!(72, std::mem::size_of::<Program<TypeOrVar>>());
}

30
src/ir/pretty.rs
View File

@@ -1,4 +1,4 @@
use crate::ir::{Expression, Primitive, Program, TopLevel, Type, TypeOrVar, Value, ValueOrRef};
use crate::ir::{Expression, Primitive, Program, Type, TypeOrVar, Value, ValueOrRef};
use crate::syntax::{self, ConstantType};
use crate::util::pretty::{derived_display, pretty_function_type, Allocator};
use pretty::{Arena, DocAllocator, DocBuilder};
@@ -57,33 +57,6 @@ impl Program<Type> {
}
}
impl TopLevel<Type> {
pub fn pretty<'a>(
&self,
allocator: &'a Arena<'a, ()>,
) -> pretty::DocBuilder<'a, Arena<'a, ()>, ()> {
match self {
TopLevel::Function(name, args, _, expr) => allocator
.text("function")
.append(allocator.space())
.append(allocator.text(name.current_name().to_string()))
.append(allocator.space())
.append(
allocator
.intersperse(
args.iter().map(|(x, _)| allocator.text(x.to_string())),
allocator.text(","),
)
.parens(),
)
.append(allocator.space())
.append(expr.pretty(allocator)),
TopLevel::Statement(stmt) => stmt.pretty(allocator),
}
}
}
impl Expression<Type> {
pub fn pretty<'a>(
&self,
@@ -267,7 +240,6 @@ impl TypeOrVar {
}
derived_display!(Program<Type>);
derived_display!(TopLevel<Type>);
derived_display!(Expression<Type>);
derived_display!(Primitive);
derived_display!(Type);