feat(runtime): support writable builtins

drake-runtime/src/lib.rs

@@ -8,11 +8,12 @@ use drake_types::ast::{
  Expression, ExpressionKind, Literal, Pattern, PatternKind, Statement, StatementKind,
  TableHeaderKind,
 };
-use drake_types::runtime::{Error, Kind, Snapshot, Table, Value};
+use drake_types::runtime::{Builtin, Error, Kind, Snapshot, Table, Value};
 
 #[derive(Clone, Debug, PartialEq)]
 struct Environment<L> {
  root: Table<L>,
+ builtin: Builtin,
  current: Option<Current<L>>,
  errors: Vec<Error<L>>,
 }
@@ -22,6 +23,7 @@ impl<L> Default for Environment<L> {
  fn default() -> Self {
  Self {
  root: Table::new(),
+ builtin: Builtin::default(),
  current: None,
  errors: Vec::new(),
  }
@@ -30,9 +32,9 @@ impl<L> Default for Environment<L> {
 
 impl<L: Clone> Environment<L> {
  fn bind(&mut self, pattern: Pattern<L>, value: Value<L>) {
- let (table, key) = match pattern.kind {
- PatternKind::Key(key) => (
- match self.current {
+ match pattern.kind {
+ PatternKind::Key(key) => {
+ let table = match self.current {
  Some(ref mut cur) => match cur.value.as_mut_table() {
  Some(table) => table,
  None => {
@@ -41,9 +43,17 @@ impl<L: Clone> Environment<L> {
  }
  },
  None => &mut self.root,
- },
- key,
- ),
+ };
+
+ if let Err(err) = table.insert(key, value) {
+ self.errors.push(err);
+ }
+ }
+ PatternKind::Builtin(key) => {
+ if let Err(err) = self.builtin.write(key, value) {
+ self.errors.push(err);
+ }
+ }
  _ => {
  self.errors.push(Error::NotSupported {
  feature: "unknown pattern",
@@ -52,10 +62,6 @@ impl<L: Clone> Environment<L> {
  return;
  }
  };
-
- if let Err(err) = table.insert(key, value) {
- self.errors.push(err);
- }
  }
 
  fn header(
@@ -99,6 +105,7 @@ impl<L: Clone> Environment<L> {
 
  Snapshot {
  root: self.root,
+ builtin: self.builtin,
  errors: self.errors,
  }
  }

drake-types/src/runtime.rs

@@ -1,6 +1,7 @@
 //! Types for runtimes
 use crate::ast::{Key, KeyKind};
 use alloc::string::String;
+use alloc::vec;
 use alloc::vec::Vec;
 use core::ops::Range;
 use hashbrown::HashMap;
@@ -9,6 +10,7 @@ use hashbrown::HashMap;
 #[derive(Clone, Debug, PartialEq)]
 pub struct Snapshot<L> {
  pub root: Table<L>,
+ pub builtin: Builtin,
  pub errors: Vec<Error<L>>,
 }
 
@@ -71,6 +73,48 @@ pub struct Table<L> {
  pub local: HashMap<String, Element<L>>,
 }
 
+#[derive(Clone, Debug, PartialEq, Default, Eq)]
+pub struct Builtin {
+ output: Option<String>,
+ filetype: Option<String>,
+}
+
+impl Builtin {
+ pub fn write<L>(&mut self, key: Key<L>, value: Value<L>) -> Result<(), Error<L>> {
+ if key.kind != KeyKind::Normal {
+ return Err(Error::BuiltinNotFound { span: key.span });
+ }
+
+ match key.name.as_str() {
+ "output" => {
+ if let Value::String(s) = value {
+ self.output = Some(s);
+ Ok(())
+ } else {
+ Err(Error::KindMismatch {
+ expect: vec![Kind::String],
+ found: value.kind(),
+ span: key.span,
+ })
+ }
+ }
+ "filetype" => {
+ if let Value::String(s) = value {
+ self.filetype = Some(s);
+ Ok(())
+ } else {
+ Err(Error::KindMismatch {
+ expect: vec![Kind::String],
+ found: value.kind(),
+ span: key.span,
+ })
+ }
+ }
+ _ => Err(Error::BuiltinNotFound { span: key.span }),
+ }
+ }
+}
+
 impl<L> Default for Table<L> {
  #[inline]
  fn default() -> Self {
@@ -152,6 +196,9 @@ pub enum Error<L> {
  found: Kind,
  span: Range<L>,
  },
+ BuiltinNotFound {
+ span: Range<L>,
+ },
  UnallowedDefaultValue {
  span: Range<L>,
  },