merged fastn-grammar into fastn-type

Cargo.toml

@@ -5,7 +5,6 @@ members = [
     "fastn-core",
     "fastn-ds",
     "fastn-expr",
-    "fastn-grammar",
     "fastn-issues",
     "fastn-js",
     "fastn-lang",
@@ -99,7 +98,6 @@ fastn-utils.path = "fastn-utils"
 fastn-runtime.path = "fastn-runtime"
 fastn-wasm.path = "fastn-wasm"
 fbt-lib.path = "fbt_lib"
-fastn-grammar.path = "fastn-grammar"
 fastn-expr.path = "fastn-expr"
 format_num = "0.1"
 ftd.path = "ftd"

fastn-js/Cargo.toml

@@ -13,7 +13,7 @@ homepage.workspace = true
 pretty.workspace = true
 itertools.workspace = true
 indoc.workspace = true
-fastn-grammar.workspace = true
+fastn-type.workspace = true
 prettify-js.workspace = true
 thiserror.workspace = true
 

fastn-js/src/conditional_component.rs

@@ -1,7 +1,7 @@
 #[derive(Debug)]
 pub struct ConditionalComponent {
     pub deps: Vec<String>,
-    pub condition: fastn_grammar::evalexpr::ExprNode,
+    pub condition: fastn_type::evalexpr::ExprNode,
     pub statements: Vec<fastn_js::ComponentStatement>,
     pub parent: String,
     pub should_return: bool,

fastn-js/src/property.rs

@@ -123,7 +123,7 @@ impl Formula {
 
 #[derive(Debug)]
 pub struct ConditionalValue {
-    pub condition: Option<fastn_grammar::evalexpr::ExprNode>,
+    pub condition: Option<fastn_type::evalexpr::ExprNode>,
     pub expression: SetPropertyValue,
 }
 

fastn-js/src/to_js.rs

@@ -886,13 +886,13 @@ impl UDFStatement {
 pub struct ExpressionGenerator;
 
 impl ExpressionGenerator {
-    pub fn to_js(&self, node: &fastn_grammar::evalexpr::ExprNode) -> String {
+    pub fn to_js(&self, node: &fastn_type::evalexpr::ExprNode) -> String {
         self.to_js_(node, true, &[], false)
     }
 
     pub fn to_js_(
         &self,
-        node: &fastn_grammar::evalexpr::ExprNode,
+        node: &fastn_type::evalexpr::ExprNode,
         root: bool,
         arguments: &[(String, Option<String>)],
         no_getter: bool,
@@ -1010,12 +1010,12 @@ impl ExpressionGenerator {
         if let Some(mut operator) = self.has_operator(node.operator()) {
             // Todo: if node.children().len() != 2 {throw error}
             let first = node.children().first().unwrap(); //todo remove unwrap()
-            if matches!(node.operator(), fastn_grammar::evalexpr::Operator::Not)
-                || matches!(node.operator(), fastn_grammar::evalexpr::Operator::Neg)
+            if matches!(node.operator(), fastn_type::evalexpr::Operator::Not)
+                || matches!(node.operator(), fastn_type::evalexpr::Operator::Neg)
             {
                 return [operator, self.to_js_(first, false, arguments, false)].join("");
             }
-            if matches!(node.operator(), fastn_grammar::evalexpr::Operator::Neq) {
+            if matches!(node.operator(), fastn_type::evalexpr::Operator::Neq) {
                 // For js conversion
                 operator = "!==".to_string();
             }
@@ -1073,56 +1073,54 @@ impl ExpressionGenerator {
         }
     }
 
-    pub fn has_value(&self, operator: &fastn_grammar::evalexpr::Operator) -> Option<String> {
+    pub fn has_value(&self, operator: &fastn_type::evalexpr::Operator) -> Option<String> {
         match operator {
-            fastn_grammar::evalexpr::Operator::Const { .. }
-            | fastn_grammar::evalexpr::Operator::VariableIdentifierRead { .. }
-            | fastn_grammar::evalexpr::Operator::VariableIdentifierWrite { .. } => {
+            fastn_type::evalexpr::Operator::Const { .. }
+            | fastn_type::evalexpr::Operator::VariableIdentifierRead { .. }
+            | fastn_type::evalexpr::Operator::VariableIdentifierWrite { .. } => {
                 Some(operator.to_string())
             }
             _ => None,
         }
     }
 
-    pub fn has_function(&self, operator: &fastn_grammar::evalexpr::Operator) -> Option<String> {
+    pub fn has_function(&self, operator: &fastn_type::evalexpr::Operator) -> Option<String> {
         match operator {
-            fastn_grammar::evalexpr::Operator::FunctionIdentifier { .. } => {
-                Some(operator.to_string())
-            }
+            fastn_type::evalexpr::Operator::FunctionIdentifier { .. } => Some(operator.to_string()),
             _ => None,
         }
     }
 
-    pub fn is_assignment(&self, operator: &fastn_grammar::evalexpr::Operator) -> bool {
-        matches!(operator, fastn_grammar::evalexpr::Operator::Assign)
+    pub fn is_assignment(&self, operator: &fastn_type::evalexpr::Operator) -> bool {
+        matches!(operator, fastn_type::evalexpr::Operator::Assign)
     }
 
-    pub fn is_chain(&self, operator: &fastn_grammar::evalexpr::Operator) -> bool {
-        matches!(operator, fastn_grammar::evalexpr::Operator::Chain)
+    pub fn is_chain(&self, operator: &fastn_type::evalexpr::Operator) -> bool {
+        matches!(operator, fastn_type::evalexpr::Operator::Chain)
     }
 
-    pub fn is_tuple(&self, operator: &fastn_grammar::evalexpr::Operator) -> bool {
-        matches!(operator, fastn_grammar::evalexpr::Operator::Tuple)
+    pub fn is_tuple(&self, operator: &fastn_type::evalexpr::Operator) -> bool {
+        matches!(operator, fastn_type::evalexpr::Operator::Tuple)
     }
 
-    pub fn is_null(&self, operator: &fastn_grammar::evalexpr::Operator) -> bool {
+    pub fn is_null(&self, operator: &fastn_type::evalexpr::Operator) -> bool {
         matches!(
             operator,
-            fastn_grammar::evalexpr::Operator::Const {
-                value: fastn_grammar::evalexpr::Value::Empty,
+            fastn_type::evalexpr::Operator::Const {
+                value: fastn_type::evalexpr::Value::Empty,
             }
         )
     }
 
-    pub fn function_name(&self, operator: &fastn_grammar::evalexpr::Operator) -> Option<String> {
-        if let fastn_grammar::evalexpr::Operator::FunctionIdentifier { identifier } = operator {
+    pub fn function_name(&self, operator: &fastn_type::evalexpr::Operator) -> Option<String> {
+        if let fastn_type::evalexpr::Operator::FunctionIdentifier { identifier } = operator {
             Some(identifier.to_string())
         } else {
             None
         }
     }
 
-    pub fn has_operator(&self, operator: &fastn_grammar::evalexpr::Operator) -> Option<String> {
+    pub fn has_operator(&self, operator: &fastn_type::evalexpr::Operator) -> Option<String> {
         if self.has_value(operator).is_none()
             && self.has_function(operator).is_none()
             && !self.is_chain(operator)
@@ -1136,8 +1134,8 @@ impl ExpressionGenerator {
         }
     }
 
-    pub fn is_root(&self, operator: &fastn_grammar::evalexpr::Operator) -> bool {
-        matches!(operator, fastn_grammar::evalexpr::Operator::RootNode)
+    pub fn is_root(&self, operator: &fastn_type::evalexpr::Operator) -> bool {
+        matches!(operator, fastn_type::evalexpr::Operator::RootNode)
     }
 }
 

fastn-js/src/udf.rs

@@ -3,13 +3,13 @@ pub struct UDF {
     pub name: String,
     pub params: Vec<String>,
     pub args: Vec<(String, fastn_js::SetPropertyValue)>,
-    pub body: Vec<fastn_grammar::evalexpr::ExprNode>,
+    pub body: Vec<fastn_type::evalexpr::ExprNode>,
     pub is_external_js_present: bool,
 }
 
 pub fn udf_with_arguments(
     name: &str,
-    body: Vec<fastn_grammar::evalexpr::ExprNode>,
+    body: Vec<fastn_type::evalexpr::ExprNode>,
     args: Vec<(String, fastn_js::SetPropertyValue)>,
     is_external_js_present: bool,
 ) -> fastn_js::Ast {

fastn-type/Cargo.toml

@@ -11,4 +11,3 @@ homepage.workspace = true
 [dependencies]
 serde.workspace = true
 # serde_json.workspace = true
-fastn-grammar.workspace = true

fastn-grammar/src/evalexpr/context/mod.rs → fastn-type/src/evalexpr/context/mod.rs

@@ -6,7 +6,7 @@
 
 use std::{collections::HashMap, iter};
 
-use fastn_grammar::evalexpr::{
+use fastn_type::evalexpr::{
     function::Function,
     value::{value_type::ValueType, Value},
     EvalexprError, EvalexprResult,
@@ -176,9 +176,9 @@ impl<'a> IterateVariablesContext<'a> for HashMapContext {
 /// # Examples
 ///
 /// ```rust
-/// use fastn_grammar::evalexpr::*;
+/// use fastn_type::evalexpr::*;
 ///
-/// let ctx = fastn_grammar::context_map! {
+/// let ctx = fastn_type::context_map! {
 ///     "x" => 8,
 ///     "f" => Function::new(|_| Ok(42.into()))
 /// }.unwrap(); // Do proper error handling here

fastn-grammar/src/evalexpr/context/predefined/mod.rs → fastn-type/src/evalexpr/context/predefined/mod.rs

@@ -4,7 +4,7 @@
 #[macro_export]
 macro_rules! math_consts_context {
     () => {
-        $fastn_grammar::evalexpr::math_consts_context!(
+        $fastn_type::evalexpr::math_consts_context!(
             PI,
             TAU,
             FRAC_PI_2,
@@ -27,8 +27,8 @@ macro_rules! math_consts_context {
         )
     };
     ($($name:ident),*) => {{
-        use $fastn_grammar::evalexpr::ContextWithMutableVariables;
-        $fastn_grammar::evalexpr::context_map! {
+        use $fastn_type::evalexpr::ContextWithMutableVariables;
+        $fastn_type::evalexpr::context_map! {
             $(
                 stringify!($name) => core::f64::consts::$name,
             )*

fastn-grammar/src/evalexpr/error/display.rs → fastn-type/src/evalexpr/error/display.rs

@@ -1,10 +1,10 @@
 use std::fmt;
 
-use fastn_grammar::evalexpr::EvalexprError;
+use fastn_type::evalexpr::EvalexprError;
 
 impl fmt::Display for EvalexprError {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        use fastn_grammar::evalexpr::EvalexprError::*;
+        use fastn_type::evalexpr::EvalexprError::*;
         match self {
             WrongOperatorArgumentAmount { expected, actual } => write!(
                 f,

fastn-grammar/src/evalexpr/error/mod.rs → fastn-type/src/evalexpr/error/mod.rs

@@ -5,9 +5,9 @@
 //! The module also contains some helper functions starting with `expect_` that check for a condition and return `Err(_)` if the condition is not fulfilled.
 //! They are meant as shortcuts to not write the same error checking code everywhere.
 
-use fastn_grammar::evalexpr::{token::PartialToken, value::value_type::ValueType};
+use fastn_type::evalexpr::{token::PartialToken, value::value_type::ValueType};
 
-use fastn_grammar::evalexpr::{operator::Operator, value::Value};
+use fastn_type::evalexpr::{operator::Operator, value::Value};
 
 // Exclude error display code from test coverage, as the code does not make sense to test.
 mod display;
@@ -368,7 +368,7 @@ pub type EvalexprResult<T> = Result<T, EvalexprError>;
 
 #[cfg(test)]
 mod tests {
-    use fastn_grammar::evalexpr::{EvalexprError, Value, ValueType};
+    use fastn_type::evalexpr::{EvalexprError, Value, ValueType};
 
     /// Tests whose only use is to bring test coverage of trivial lines up, like trivial constructors.
     #[test]

fastn-grammar/src/evalexpr/feature_serde/mod.rs → fastn-type/src/evalexpr/feature_serde/mod.rs

@@ -1,4 +1,4 @@
-use fastn_grammar::evalexpr::{interface::build_operator_tree, ExprNode};
+use fastn_type::evalexpr::{interface::build_operator_tree, ExprNode};
 use serde::{de, Deserialize, Deserializer};
 use std::fmt;
 

fastn-grammar/src/evalexpr/function/builtin.rs → fastn-type/src/evalexpr/function/builtin.rs

@@ -1,4 +1,4 @@
-use fastn_grammar::evalexpr::{
+use fastn_type::evalexpr::{
     value::{FloatType, IntType},
     EvalexprError, Function, Value, ValueType,
 };

fastn-grammar/src/evalexpr/function/mod.rs → fastn-type/src/evalexpr/function/mod.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use fastn_grammar::evalexpr::{error::EvalexprResult, value::Value};
+use fastn_type::evalexpr::{error::EvalexprResult, value::Value};
 
 pub(crate) mod builtin;
 
@@ -30,7 +30,7 @@ where
 /// # Examples
 ///
 /// ```rust
-/// use fastn_grammar::evalexpr::*;
+/// use fastn_type::evalexpr::*;
 ///
 /// let mut context = HashMapContext::new();
 /// context.set_function("id".into(), Function::new(|argument| {

fastn-grammar/src/evalexpr/interface/mod.rs → fastn-type/src/evalexpr/interface/mod.rs

@@ -1,4 +1,4 @@
-use fastn_grammar::evalexpr::{
+use fastn_type::evalexpr::{
     token, tree, value::TupleType, Context, ContextWithMutableVariables, EmptyType, EvalexprError,
     EvalexprResult, ExprNode, FloatType, HashMapContext, IntType, Value, EMPTY_VALUE,
 };
@@ -8,7 +8,7 @@ use fastn_grammar::evalexpr::{
 /// # Examples
 ///
 /// ```rust
-/// use fastn_grammar::evalexpr::*;
+/// use fastn_type::evalexpr::*;
 ///
 /// assert_eq!(eval("1 + 2 + 3"), Ok(Value::from(6)));
 /// ```
@@ -23,7 +23,7 @@ pub fn eval(string: &str) -> EvalexprResult<Value> {
 /// # Examples
 ///
 /// ```rust
-/// use fastn_grammar::evalexpr::*;
+/// use fastn_type::evalexpr::*;
 ///
 /// let mut context = HashMapContext::new();
 /// context.set_value("one".into(), 1.into()).unwrap(); // Do proper error handling here
@@ -42,7 +42,7 @@ pub fn eval_with_context<C: Context>(string: &str, context: &C) -> EvalexprResul
 /// # Examples
 ///
 /// ```rust
-/// use fastn_grammar::evalexpr::*;
+/// use fastn_type::evalexpr::*;
 ///
 /// let mut context = HashMapContext::new();
 /// context.set_value("one".into(), 1.into()).unwrap(); // Do proper error handling here
@@ -67,7 +67,7 @@ pub fn eval_with_context_mut<C: ContextWithMutableVariables>(
 /// # Examples
 ///
 /// ```rust
-/// use fastn_grammar::evalexpr::*;
+/// use fastn_type::evalexpr::*;
 ///
 /// let precomputed = build_operator_tree("one + two + three").unwrap(); // Do proper error handling here
 ///