ast-generator/src/build_fn_gen.rs

@@ -1,6 +1,5 @@
 use crate::spec::{
-    BuildBooleanOn, ChildSpec, SingleBooleanChildToBuild, SingleChildToBuild,
+    BuildBooleanOn, ChildSpec, SingleChildToBuild, StructBuildSpec, VecChildToBuild,
-    SingleTypeChildToBuild, StructBuildSpec, VecChild, VecChildToBuild,
 };
 use convert_case::{Case, Casing};
 use proc_macro2::TokenStream;
@@ -10,45 +9,33 @@ pub fn make_build_fn_name(s: &str) -> String {
     format!("build_{}", s.to_case(Case::Snake))
 }
 
-fn make_vec_child_holder(vec_child: &VecChild) -> TokenStream {
-    let (child_ident, child_type_ident) = match vec_child.build() {
-        VecChildToBuild::Type(vec_type_child) => (
-            format_ident!("{}", vec_type_child.var_name()),
-            format_ident!("{}", vec_type_child.build()),
-        ),
-    };
-    quote! {
-        let mut #child_ident: Vec<Box<#child_type_ident>> = vec![]
-    }
-}
-
-fn make_single_type_child_holder(single_type_child: &SingleTypeChildToBuild) -> TokenStream {
-    let child_ident = format_ident!("{}", single_type_child.var_name());
-    let child_type_ident = format_ident!("{}", single_type_child.build());
-    quote! {
-        let mut #child_ident: Option<Box<#child_type_ident>> = None
-    }
-}
-
-fn make_single_boolean_child_holder(
-    single_boolean_child: &SingleBooleanChildToBuild,
-) -> TokenStream {
-    let child_ident = format_ident!("{}", single_boolean_child.var_name());
-    quote! {
-        let mut #child_ident: bool = false
-    }
-}
-
 fn make_child_holder(child_spec: &ChildSpec) -> Option<TokenStream> {
     match child_spec {
         ChildSpec::SkipChild(_) => None,
-        ChildSpec::VecChild(vec_child) => Some(make_vec_child_holder(vec_child)),
+        ChildSpec::VecChild(vec_child) => {
+            let (child_ident, child_type_ident) = match vec_child.build() {
+                VecChildToBuild::Type(vec_type_child) => (
+                    format_ident!("{}", vec_type_child.var_name()),
+                    format_ident!("{}", vec_type_child.build()),
+                ),
+            };
+            Some(quote! {
+                let mut #child_ident: Vec<#child_type_ident> = vec![]
+            })
+        }
         ChildSpec::SingleChild(single_child) => match single_child.build() {
             SingleChildToBuild::Type(single_type_child) => {
-                Some(make_single_type_child_holder(single_type_child))
+                let child_ident = format_ident!("{}", single_type_child.var_name());
+                let child_type_ident = format_ident!("{}", single_type_child.build());
+                Some(quote! {
+                    let mut #child_ident: Option<#child_type_ident> = None;
+                })
             }
             SingleChildToBuild::Boolean(boolean_child) => {
-                Some(make_single_boolean_child_holder(boolean_child))
+                let child_ident = format_ident!("{}", boolean_child.var_name());
+                Some(quote! {
+                    let #child_ident: bool = false
+                })
             }
         },
     }
@@ -65,7 +52,7 @@ fn make_match_action(child_spec: &ChildSpec) -> TokenStream {
                 ),
             };
             quote! {
-                #child_name_ident.push(Box::new(#build_fn_ident(inner_pair)))
+                #child_name_ident.push(#build_fn_ident(inner_pair))
             }
         }
         ChildSpec::SingleChild(single_child) => match single_child.build() {
@@ -73,7 +60,7 @@ fn make_match_action(child_spec: &ChildSpec) -> TokenStream {
                 let child_name_ident = format_ident!("{}", single_type_child.var_name());
                 let build_fn_ident = format_ident!("{}", single_type_child.with());
                 quote! {
-                    #child_name_ident = Some(Box::new(#build_fn_ident(inner_pair)))
+                    #child_name_ident = Some(#build_fn_ident(inner_pair))
                 }
             }
             SingleChildToBuild::Boolean(single_boolean_child) => {
@@ -103,57 +90,6 @@ fn make_rule_matcher(child_spec: &ChildSpec) -> TokenStream {
     }
 }
 
-fn make_child_arg(child_spec: &ChildSpec) -> Option<TokenStream> {
-    match child_spec {
-        ChildSpec::SkipChild(_) => None,
-        ChildSpec::VecChild(vec_child) => {
-            let child_ident = match vec_child.build() {
-                VecChildToBuild::Type(vec_type_child) => {
-                    format_ident!("{}", vec_type_child.var_name())
-                }
-            };
-            Some(quote! { #child_ident })
-        }
-        ChildSpec::SingleChild(single_child) => match single_child.build() {
-            SingleChildToBuild::Type(single_type_child) => {
-                let child_ident = format_ident!("{}", single_type_child.var_name());
-                if single_type_child.optional() {
-                    Some(quote! { #child_ident })
-                } else if let Some(or_else) = single_type_child.or_else() {
-                    let child_type_ident = format_ident!("{}", single_type_child.build());
-                    let or_else_ident = format_ident!("{}", or_else);
-                    Some(quote! {
-                        #child_ident.unwrap_or_else(|| Box::new(#child_type_ident::#or_else_ident()))
-                    })
-                } else {
-                    Some(quote! { #child_ident.unwrap() })
-                }
-            }
-            SingleChildToBuild::Boolean(single_boolean_child) => {
-                let child_ident = format_ident!("{}", single_boolean_child.var_name());
-                Some(quote! { #child_ident })
-            }
-        },
-    }
-}
-
-fn make_return_value_stream(build_spec: &StructBuildSpec) -> TokenStream {
-    let type_ident = format_ident!("{}", build_spec.build());
-    let child_args = build_spec
-        .children()
-        .iter()
-        .map(|child| make_child_arg(child))
-        .filter(|child_arg| child_arg.is_some())
-        .map(|child_arg| child_arg.unwrap())
-        .collect::<Vec<_>>();
-
-    quote! {
-        #type_ident::new(
-            #(#child_args,)*
-        )
-    }
-}
-
 pub fn make_struct_build_fn(build_spec: &StructBuildSpec) -> TokenStream {
     let build_fn_ident = format_ident!("{}", build_spec.with());
     let pair_ident = format_ident!("{}_pair", build_spec.build().to_case(Case::Snake));
@@ -181,66 +117,11 @@ pub fn make_struct_build_fn(build_spec: &StructBuildSpec) -> TokenStream {
         }
     };
 
-    let new_stream = make_return_value_stream(build_spec);
-
     quote! {
         fn #build_fn_ident(#pair_ident: Pair<Rule>) -> #return_type_ident {
             #(#child_holders;)*
 
             #iter_stream
-
-            #new_stream
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::spec::VecTypeChildToBuild;
-
-    #[test]
-    fn vec_child_holder() {
-        let vec_child = VecChild::new(
-            "test_child",
-            "Test",
-            VecChildToBuild::Type(VecTypeChildToBuild::new(
-                "TestType",
-                "test_child",
-                "build_test_child",
-            )),
-        );
-        assert_eq!(
-            make_vec_child_holder(&vec_child).to_string(),
-            quote! {
-                let mut test_child: Vec<Box<TestType>> = vec![]
-            }
-            .to_string()
-        );
-    }
-
-    #[test]
-    fn single_type_child_holder() {
-        let single_type_child = SingleTypeChildToBuild::from_build_or_rule("TestType", None, false);
-        assert_eq!(
-            make_single_type_child_holder(&single_type_child).to_string(),
-            quote! {
-                let mut test_type: Option<Box<TestType>> = None
-            }
-            .to_string()
-        );
-    }
-
-    #[test]
-    fn single_boolean_child_holder() {
-        let single_boolean_child =
-            SingleBooleanChildToBuild::new("test_child", BuildBooleanOn::RulePresent);
-        assert_eq!(
-            make_single_boolean_child_holder(&single_boolean_child).to_string(),
-            quote! {
-                let mut test_child: bool = false
-            }
-            .to_string()
-        );
-    }
-}

ast-generator/src/deserialize.rs

@@ -46,58 +46,35 @@ fn get_vec_child(name: &str, rule: &str, build: &Yaml) -> ChildSpec {
     ))
 }
 
-fn get_single_child_to_build(name: &str, rule: &str, optional: bool, build: &Yaml) -> SingleChildToBuild {
+fn get_single_child_to_build(name: &str, rule: &str, build: &Yaml) -> SingleChildToBuild {
     if build.is_hash() {
-        match build["type"].as_str() {
+        let r#type = build["type"].as_str().unwrap();
-            Some(r#type) => {
+        let var_name = build["var"]
-                let var_name = build["var"]
+            .as_str()
-                    .as_str()
+            .map(|s| s.to_string())
-                    .map(|s| s.to_string())
+            .unwrap_or(name.to_string());
-                    .unwrap_or(name.to_string());
+        let on = build["on"].as_str().unwrap();
-                let on = build["on"].as_str().unwrap();
+        if r#type.eq("boolean") && on.eq("rule_present") {
-                if r#type.eq("boolean") && on.eq("rule_present") {
+            SingleChildToBuild::Boolean(SingleBooleanChildToBuild::new(
-                    SingleChildToBuild::Boolean(SingleBooleanChildToBuild::new(
+                &var_name,
-                        &var_name,
+                BuildBooleanOn::RulePresent,
-                        BuildBooleanOn::RulePresent,
+            ))
-                    ))
+        } else {
-                } else {
+            todo!("currently on boolean types with on: rule_present are supported")
-                    todo!("currently on boolean types with on: rule_present are supported")
-                }       
-            },
-            None => {
-                let or_else = build["or_else"]
-                    .as_str()
-                    .map(|s| s.to_string())
-                    .or_else(|| {
-                        let or_else_default = build["or_else_default"]
-                            .as_bool()
-                            .unwrap_or_else(|| false);
-                        if or_else_default {
-                            Some(String::from("default"))
-                        } else {
-                            None
-                        }
-                    });
-                SingleChildToBuild::Type(SingleTypeChildToBuild::from_build_or_rule(
-                    rule,
-                    or_else,
-                    optional,
-                ))
-            }
         }
     } else {
         match build.as_str() {
-            Some(s) => SingleChildToBuild::Type(SingleTypeChildToBuild::from_build_or_rule(s, None, optional)),
+            Some(s) => SingleChildToBuild::Type(SingleTypeChildToBuild::from_build_or_rule(s)),
-            None => SingleChildToBuild::Type(SingleTypeChildToBuild::from_build_or_rule(rule, None, optional)),
+            None => SingleChildToBuild::Type(SingleTypeChildToBuild::from_build_or_rule(rule)),
         }
     }
 }
 
-fn get_single_child(name: &str, rule: &str, optional: bool, build: &Yaml) -> ChildSpec {
+fn get_single_child(name: &str, rule: &str, build: &Yaml) -> ChildSpec {
     ChildSpec::SingleChild(SingleChild::new(
         name,
         rule,
-        get_single_child_to_build(name, rule, optional, build),
+        get_single_child_to_build(name, rule, build),
     ))
 }
 
@@ -115,25 +92,18 @@ fn get_child_specs(children: &Yaml) -> Vec<ChildSpec> {
                     .map(|(name, props)| (name.as_str().unwrap(), props))
                     .unwrap();
 
-                let rule = props["rule"]
+                let rule = props["rule"].as_str().unwrap();
-                    .as_str()
-                    .map(|s| s.to_string())
-                    .unwrap_or(name.to_case(Case::Pascal));
 
                 if get_skip(&props["skip"]) {
-                    return ChildSpec::SkipChild(SkipChild::new(name, &rule));
+                    return ChildSpec::SkipChild(SkipChild::new(name, rule));
                 }
 
                 let build = &props["build"];
 
                 if get_vec(&props["vec"]) {
-                    get_vec_child(name, &rule, build)
+                    get_vec_child(name, rule, build)
                 } else {
-                    let optional = props["optional"]
+                    get_single_child(name, rule, build)
-                        .as_bool()
-                        .unwrap_or_else(|| false);
-                    
-                    get_single_child(name, &rule, optional, build)
                 }
             } else {
                 ChildSpec::SingleChild(SingleChild::from_name_snake(child_spec.as_str().unwrap()))

ast-generator/src/lib.rs

@@ -9,7 +9,6 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use spec::BuildSpec;
 use syn::File;
-use syn::spanned::Spanned;
 
 fn debug_built_spec(build_spec: &BuildSpec, token_stream: &TokenStream) {
     println!("*** BuildSpec ***");

ast-generator/src/spec.rs

@@ -233,8 +233,6 @@ impl SingleChild {
             rule: name.to_case(Case::Pascal),
             build: SingleChildToBuild::Type(SingleTypeChildToBuild::from_build_or_rule(
                 &name.to_case(Case::Pascal),
-                None,
-                false,
             )),
         }
     }
@@ -274,22 +272,14 @@ pub struct SingleTypeChildToBuild {
     build: String,
     var_name: String,
     with: String,
-    or_else: Option<String>,
-    optional: bool,
 }
 
 impl SingleTypeChildToBuild {
-    pub fn from_build_or_rule(
+    pub fn from_build_or_rule(build_or_rule: &str) -> Self {
-        build_or_rule: &str,
-        or_else: Option<String>,
-        optional: bool,
-    ) -> Self {
         Self {
             build: build_or_rule.to_string(),
             var_name: build_or_rule.to_case(Case::Snake),
             with: make_build_fn_name(build_or_rule),
-            or_else,
-            optional,
         }
     }
 
@@ -307,16 +297,6 @@ impl SingleTypeChildToBuild {
     pub fn with(&self) -> &str {
         &self.with
     }
-
-    /// The default fn to call when unwrapping the child (before passing as arg to new).
-    pub fn or_else(&self) -> Option<&str> {
-        self.or_else.as_deref()
-    }
-
-    /// If the type should be wrapped in an Option.
-    pub fn optional(&self) -> bool {
-        self.optional
-    }
 }
 
 #[derive(Debug)]

ast-generator/src/type_gen.rs

@@ -64,15 +64,9 @@ fn handle_single_type_child(
     let child_ident_mut = format_ident!("{}_mut", single_type_child.var_name());
     let child_type_ident = format_ident!("{}", single_type_child.build());
     member_names.push(child_ident.clone());
-    if single_type_child.optional() {
+    annotated_members.push(quote! {
-        annotated_members.push(quote! {
+        #child_ident: Box<#child_type_ident>
-            #child_ident: Option<Box<#child_type_ident>>
+    });
-        });
-    } else {
-        annotated_members.push(quote! {
-            #child_ident: Box<#child_type_ident>
-        })
-    }
     accessors.push(quote! {
         pub fn #child_ident(&self) -> &#child_type_ident {
             self.#child_ident.as_ref()

sketching/september_2025/adder/adder.dm

@@ -1,5 +0,0 @@
-use math::add
-
-fn main()
-    println add(1, 2) // 3
-end

sketching/september_2025/adder/math/add.dm

@@ -1,3 +0,0 @@
-mod math
-
-pub fn add(a: Int, b: Int) = a + b

src/parser/ast.schema.yaml

@@ -9,52 +9,22 @@ $defs:
     type: object
     additionalProperties: false
     description: A definition of a node type.
-    oneOf:
-      - $ref: "#/$defs/StructNodeDefinition"
-      - $ref: "#/$defs/EnumNodeDefinition"
-      - $ref: "#/$defs/LeafEnumNodeDefinition"
-  StructNodeDefinition:
-    type: object
-    additionalProperties: false
-    description: A description of a Struct node to be built.
     properties:
-      type:
-        const: struct
       children:
+        type: array
         description: Ordered child fields for this node.
         items:
           $ref: "#/$defs/StructChildDefinition"
-    required:
-      - children
-  EnumNodeDefinition:
-    type: object
-    additionalProperties: false
-    description: A description of an Enum node to be built.
-    properties:
-      type:
-        const: enum
       rules:
         type: array
         description: Alternative parse rules that build this node.
         items:
           $ref: "#/$defs/EnumChildDefinition"
-    required:
+    oneOf:
-      - rules
+      - required:
-  LeafEnumNodeDefinition:
+          - "children"
-    type: object
+      - required:
-    additionalProperties: false
+          - "rules"
-    description: A description of a leaf-enum node to be built.
-    properties:
-      type:
-        const: leaf_enum
-      rules:
-        type: array
-        description: Alternative parse rules that build this node.
-        items:
-          $ref: "#/$defs/LeafEnumChildDefinition"
-    required:
-      - type
-      - rules
   StructChildDefinition:
     description: A definition of a node's child. Either a bare child name (string) in snake case, or an object.
     oneOf:
@@ -108,36 +78,18 @@ $defs:
     properties:
       rule:
         type: string
-        description: The type to build, in Pascal case.
-      optional:
-        type: boolean
-        description: If true, this child will be stored as an Option.
       build:
         oneOf:
           - type: string
           - $ref: "#/$defs/SingleChildBuildDefinition"
+    required:
+      - rule
   SingleChildBuildDefinition:
     type: object
     additionalProperties: false
     description: A definition of what exactly to build for a given child rule.
     oneOf:
-      - $ref: "#/$defs/BuildSingleTypeChild"
       - $ref: "#/$defs/BuildBooleanChild"
-      - $ref: "#/$defs/BuildStringChild"
-      - $ref: "#/$defs/BuildDoubleChild"
-      - $ref: "#/$defs/BuildIntChild"
-      - $ref: "#/$defs/BuildLongChild"
-  BuildSingleTypeChild:
-    type: object
-    additionalProperties: false
-    description: A definition of a single-type child to build.
-    properties:
-      or_else:
-        type: string
-        description: The method name to call upon the built-type if the rule is not found. Takes precedence over "or_else_default".
-      or_else_default:
-        type: boolean
-        description: Whether to call the default method on the built-type if the rule is not found.
   BuildBooleanChild:
     type: object
     additionalProperties: false
@@ -151,54 +103,6 @@ $defs:
         type: string
         enum:
           - rule_present
-      from:
-        type: string
-        enum: 
-          - parse_whole_pair
-  BuildStringChild:
-    type: object
-    additionalProperties: false
-    description: A definition for building a string child.
-    properties: 
-      type:
-        const: string
-      from:
-        type: string
-        enum:
-          - whole_pair
-  BuildDoubleChild:
-    type: object
-    additionalProperties: false
-    description: A definition for building a Double child.
-    properties: 
-      type:
-        const: f64
-      from:
-        type: string
-        enum:
-          - parse_whole_pair
-  BuildIntChild:
-    type: object
-    additionalProperties: false
-    description: A definition for building an Int child.
-    properties: 
-      type:
-        const: i32
-      from:
-        type: string
-        enum:
-          - parse_number_base
-  BuildLongChild:
-    type: object
-    additionalProperties: false
-    description: A definition for building a Long child.
-    properties: 
-      type:
-        const: i64
-      from:
-        type: string
-        enum:
-          - parse_number_base
   EnumChildDefinition:
     description: A definition of an enum node's child. Either a bare rule (string) in Pascal case, or an object.
     oneOf:
@@ -217,28 +121,3 @@ $defs:
     required:
       - rule
       - build
-  LeafEnumChildDefinition:
-    description: A definition of a leaf-enum node's child. Either a bare rule-string in Pascal case, or an object.
-    oneOf:
-      - type: string
-        description: Shorthand where the rule name maps onto an empty enum rule.
-      - $ref: "#/$defs/LongLeafEnumChildDefinitionWrapper"
-  LongLeafEnumChildDefinitionWrapper:
-    type: object
-    description: Single-key object mapping the child-name to its spec.
-    minProperties: 1
-    maxProperties: 1
-    additionalProperties: false
-    patternProperties:
-      "^([A-Z][a-z0-9]*)*$":
-        $ref: "#/$defs/LongLeafEnumChildDefinition"
-  LongLeafEnumChildDefinition:
-    type: object
-    additionalProperties: false
-    description: A format for specifying more specific information about a leaf-enum child.
-    properties:
-      child:
-        type: boolean
-        description: If true, a node of the same name is built as the lone member of the enum child.
-    required:
-      - child

src/parser/ast.yaml

@@ -1,35 +1,19 @@
 # $schema: ./ast.schema.yaml
-
-# Names
-Identifier:
-  children:
-    - literal:
-        build:
-          type: string
-          from: parse_whole_pair
-FullyQualifiedName:
-  children:
-    - identifiers:
-        rule: Identifier
-        vec: true
-
-# Top-level constructs
 CompilationUnit:
   children:
-    - parent_mod
+    - namespace
     - use_statements:
         rule: UseStatement
         vec: true
     - module_level_declarations:
         rule: ModuleLevelDeclaration
-        vec: true
+Namespace:
-ParentMod:
   children:
-    - mod_kw:
+    - ns_kw:
-        rule: Mod
+        rule: Ns
         skip: true
     - fqn:
-        rule: FullyQualifiedName
+        rule: Fqn
 UseStatement:
   children:
     - use_kw:
@@ -40,49 +24,17 @@ UseStatement:
         vec: true
     - suffix:
         rule: UseStatementSuffix
-UseStatementPrefix:
-  children:
-    - identifier
-UseStatementSuffix:
-  rules:
-    - Identifier
-    - rule: Star
-      build: UseStatementStarSuffix
-    - UseList
-UseList:
-  children:
-    - identifiers:
-        rule: Identifier
-        vec: true
-
-# Level declarations
 ModuleLevelDeclaration:
   rules:
-    - Module
+    - rule: Module
-    - Interface
+      build: ModuleDeclaration
-    - Class
+    - rule: Interface
-    - Function
+      build: InterfaceDeclaration
+    - rule: Class
+      build: ClassDeclaration
+    - FunctionDefinition
     - PlatformFunction
-InterfaceLevelDeclaration:
+ModuleDeclaration:
-  rules:
-    - CompanionModule
-    - Interface
-    - Class
-    - InterfaceFunction
-    - InterfaceDefaultFunction
-    - InterfaceOperatorFunction
-    - InterfaceDefaultOperatorFunction
-ClassLevelDeclaration:
-  children:
-    - CompanionModule
-    - Interface
-    - Class
-    - Function
-    - OperatorFunction
-    - PlatformFunction
-
-# Main organizational constructs
-Module:
   children:
     - is_public:
         rule: Pub
@@ -97,47 +49,7 @@ Module:
     - declarations:
         rule: ModuleLevelDeclaration
         vec: true
-    - end_kw:
+ClassDeclaration:
-        rule: End
-        skip: true
-CompanionModule:
-  children:
-    - companion_kw:
-        rule: Companion
-        skip: true
-    - mod_kw:
-        rule: Mod
-        skip: true
-    - declarations:
-        rule: ModuleLevelDeclaration
-        vec: true
-    - end_kw:
-        rule: End
-        skip: true
-Interface:
-  children:
-    - is_public:
-        rule: Pub
-        build:
-          type: boolean
-          on: rule_present
-    - int_kw:
-        rule: IntKw
-        skip: true
-    - identifier
-    - generic_parameters:
-        build:
-          or_else_default: true
-    - implements_list:
-        build:
-          or_else_default: true
-    - declarations:
-        rule: InterfaceLevelDeclaration
-        vec: true
-    - end_kw:
-        rule: End
-        skip: true
-Class:
   children:
     - is_public:
         rule: Pub
@@ -148,27 +60,22 @@ Class:
         rule: ClassKw
         skip: true
     - identifier
-    - generic_parameters:
+    - generic_parameters
-        build:
+    - class_constructor
-          or_else_default: true
+    - implements_list
-    - class_constructor:
-        build:
-          or_else_default: true
-    - implements_list:
-        build:
-          or_else_default: true
     - class_level_declarations:
         rule: ClassLevelDeclaration
         vec: true
-
+FunctionDeclaration:
-# Function constructs
-Function:
   children:
     - is_public:
         rule: Pub
         build:
           type: boolean
           on: rule_present
+    - modifier:
+        rule: Modifier
+        build: FunctionModifier
     - fn_kw:
         rule: Fn
         skip: true
@@ -176,561 +83,5 @@ Function:
         rule: GenericParameters
     - identifier
     - parameters
-    - return_type:
-        build:
-          or_else: void
-    - function_body
-OperatorFunction:
-  children:
-    - is_public:
-        rule: Pub
-        build:
-          type: boolean
-          on: rule_present
-    - op_kw:
-        rule: Op
-        skip: true
-    - generics:
-        rule: GenericParameters
-        build:
-          or_else_default: true
-    - operator
-    - parameters
-    - return_type:
-        build:
-          or_else: void
-    - function_body
-PlatformFunction:
-  children:
-    - is_public:
-        rule: Pub
-        build:
-          type: boolean
-          on: rule_present
-    - platform_kw:
-        rule: Platform
-        skip: true
-    - fn_kw:
-        rule: Fn
-        skip: true
-    - generics:
-        rule: GenericParameters
-        build:
-          or_else_default: true
-    - identifier
-    - parameters
     - return_type
-InterfaceFunction:
-  children:
-    - fn_kw:
-        rule: Fn
-        skip: true
-    - generics:
-        rule: GenericParameters
-        build:
-          or_else_default: true
-    - identifier
-    - parameters
-    - return_type
-InterfaceDefaultFunction:
-  children:
-    - def_kw:
-        rule: Def
-        skip: true
-    - fn_kw:
-        rule: Fn
-        skip: true
-    - generics:
-        rule: GenericParameters
-        build:
-          or_else_default: true
-    - identifier
-    - parameters
-    - return_type:
-        build:
-          or_else: void
     - function_body
-InterfaceOperatorFunction:
-  children:
-    - op_kw:
-        rule: Op
-        skip: true
-    - generics:
-        rule: GenericParameters
-        build:
-          or_else_default: true
-    - operator
-    - parameters
-    - return_type
-InterfaceDefaultOperatorFunction:
-  children:
-    - def_kw:
-        rule: Def
-        skip: true
-    - op_kw:
-        rule: Op
-        skip: true
-    - generics:
-        rule: GenericParameters
-        build:
-          or_else_default: true
-    - operator
-    - parameters
-    - return_type:
-        build:
-          or_else: void
-    - function_body
-      
-# Function Bodies
-FunctionBody:
-  rules:
-    - FunctionAliasBody
-    - FunctionEqualsBody
-    - FunctionBlockBody
-FunctionEqualsBody:
-  children:
-    - expression
-FunctionAliasBody:
-  children:
-    - alias_kw:
-        rule: Alias
-        skip: true
-    - identifier
-FunctionBlockBody:
-  children:
-    - statements:
-        rule: Statement
-        vec: true
-    - end_kw:
-        rule: End
-        skip: true
-
-# Class constructs
-ClassConstructor:
-  children:
-    - members:
-        rule: Member
-        vec: true
-Member:
-  children:
-    - is_public:
-        rule: Pub
-        build: 
-          type: boolean
-          on: rule_present
-    - is_mut:
-        rule: Mut
-        build:
-          type: boolean
-          on: rule_present
-    - identifier
-    - type_use
-
-# Statements
-Statement:
-  rules:
-    - VariableDeclaration
-    - AssignmentStatement
-    - ExpressionStatement
-    - UseStatement
-    - IfElseStatement
-    - IfStatementStatement
-    - WhileStatement
-    - ForStatement
-VariableDeclaration:
-  children:
-    - let_kw:
-        rule: Let
-        skip: true
-    - is_mut:
-        rule: Mut
-        build:
-          type: boolean
-          on: rule_present
-    - identifier
-    - type_use:
-        optional: true
-    - expression:
-        optional: true
-AssignmentStatement:
-  children:
-    - left:
-        rule: Expression
-    - right:
-        rule: Expression
-ExpressionStatement:
-  children:
-    - expression
-IfStatement:
-  children:
-    - if_clause
-    - if_else_ifs:
-        rule: IfElseIf
-        vec: true
-    - if_else
-    - end_kw:
-        rule: End
-        skip: true
-IfClause:
-  children:
-    - if_kw:
-        rule: If
-        skip: true
-    - expression
-    - then_kw:
-        rule: Then
-        skip: true
-    - statements:
-        rule: Statement
-        vec: true
-IfElseIf:
-  children:
-    - else_kw:
-        rule: Else
-        skip: true
-    - if_clause
-IfElse:
-  children:
-    - else_kw:
-        rule: Else
-        skip: true
-    - statements:
-        rule: Statement
-        vec: true
-WhileStatement:
-  children:
-    - while_kw:
-        rule: While
-        skip: true
-    - expression
-    - do_kw:
-        rule: Do
-        skip: true
-    - statements:
-        rule: Statement
-        vec: true
-    - end_kw:
-        rule: End
-        skip: true
-ForStatement:
-  children:
-    - for_kw:
-        rule: For
-        skip: true
-    - identifier
-    - in_kw:
-        rule: In
-        skip: true
-    - expression
-    - do_kw:
-        rule: Do
-        skip: true
-    - statement:
-        rule: Statement
-        vec: true
-    - end_kw:
-        rule: End
-        vec: true
-
-# Expressions
-Expression:
-  children:
-    - ternary_expression
-TernaryExpression:
-  children:
-    - or_expression
-    - ternary_alternatives:
-        optional: true
-TernaryAlternatives:
-  children:
-    - ternary_true_alternative
-    - ternary_false_alternative
-TernaryTrueAlternative:
-  children:
-    - expression
-TernaryFalseAlternative:
-  children:
-    - expression
-OrExpression:
-  children:
-    - left:
-        rule: AndExpression
-    - or_sym:
-        rule: Or
-        skip: true
-    -  right:
-         rule: Expression
-         optional: true
-AndExpression:
-  children:
-    - left:
-        rule: ComparisonExpression
-    - and_sym:
-        rule: And
-        skip: true
-    - right:
-        rule: Expression
-        optional: true
-ComparisonExpression:
-  children:
-    - left: 
-        rule: ShiftExpression
-    - operator:
-        rule: ComparisonOperator
-        optional: true
-    - right:
-        rule: Expression
-        optional: true
-ComparisonOperator:
-  rules:
-    - Greater
-    - Less
-    - GreaterEqual
-    - LessEqual
-    - EqualTo
-    - NotEqualTo
-ShiftExpression:
-  children:
-    - left:
-        rule: AdditiveExpression
-    - operator:
-        rule: ShiftOperator
-        optional: true
-    - right:
-        rule: Expression
-ShiftOperator:
-  rules:
-    - LeftShift
-    - RightShift
-AdditiveExpression:
-  children:
-    - left:
-        rule: MultiplicativeExpression
-    - operator:
-        rule: AdditiveOperator
-        optional: true
-    - right:
-        rule: Expression
-        optional: true
-MultiplicativeExpression:
-  children:
-    - left:
-        rule: PrefixExpression
-    - operator:
-        rule: MultiplicativeOperator
-        optional: true
-    - right:
-        rule: Expression
-MultiplicativeOperator:
-  type: leaf_enum
-  rules:
-    - Multiply
-    - Divide
-    - Modulo
-PrefixExpression:
-  children:
-    - operators:
-        rule: PrefixOperator
-        vec: true
-PrefixOperator:
-  type: leaf_enum
-  rules:
-    - Spread
-    - Not
-    - Negative
-SuffixExpression:
-  children:
-    - left:
-        rule: PrimaryExpression
-    - operators:
-        rule: SuffixOperator
-        vec: true
-SuffixOperator:
-  type: leaf_enum
-  rules:
-    - PlusPlus
-    - MinusMinus
-    - ObjectProperty:
-        child: true
-    - ObjectIndex:
-        child: true
-    - Call:
-        child: true
-ObjectProperty:
-  children:
-    - identifier
-ObjectIndex:
-  children:
-    - expression
-PrimaryExpression:
-  rules:
-    - Literal
-    - FullyQualifiedName
-    - Closure
-    - ParenthesizedExpression
-ParenthesizedExpression:
-  children:
-    - expression
-
-# Calls
-Call:
-  rules:
-    - ParenthesesCall
-    - NonParenthesesCall
-ParenthesesCall:
-  children:
-    - turbo_fish:
-        optional: true
-    - expression_list:
-        optional: true
-    - closure:
-        optional: true
-NonParenthesesCall:
-  children:
-    - turbo_fish:
-        optional: true
-    - expression_list:
-        optional: true
-    - closure:
-        optional: true
-TurboFish:
-  children:
-    - generic_arguments
-ExpressionList:
-  children:
-    - expressions:
-        rule: Expression
-        vec: true
-
-# Closure
-Closure:
-  children:
-    - closure_parameters:
-        build:
-          or_else_default: true
-    - statements:
-        rule: Statement
-        vec: true
-ClosureParameters:
-  children:
-    - parameters:
-        rule: ClosureParameters
-        vec: true
-ClosureParameter:
-  children:
-    - identifier
-    - type_use:
-        optional: true
-
-# Literals
-Literal:
-  rules:
-    - NumberLiteral
-    - StringLiteral
-    - BooleanLiteral
-NumberLiteral:
-  rules:
-    - DoubleLiteral
-    - LongLiteral
-    - IntLiteral
-IntLiteral:
-  children:
-    - number_base
-    - literal:
-        build:
-          type: i32
-          from: parse_number_base
-LongLiteral:
-  children:
-    - number_base
-    - literal:
-        build:
-          type: i64
-          from: parse_number_base
-DoubleLiteral:
-  children:
-    - literal:
-        build: 
-          type: f64
-          from: parse_whole_pair
-NumberBase:
-  rules:
-    - BinaryBase
-    - HexadecimalBase
-    - DecimalBase
-DecimalBase:
-  children:
-    - literal:
-        build: 
-          type: string
-          from: whole_pair
-BinaryBase:
-  children:
-    - binary_digits
-BinaryDigits:
-  children:
-    - literal:
-        build:
-          type: string
-          from: whole_pair
-HexadecimalBase:
-  children:
-    - hexadecimal_digits
-HexadecimalDigits:
-  children:
-    - literal:
-        build: 
-          type: string
-          from: whole_pair
-StringLiteral:
-  rules:
-    - SingleQuoteString
-    - DoubleQuoteString
-    - BacktickString
-SingleQuoteString:
-  children:
-    - string_inner:
-        optional: true
-DoubleQuoteString:
-  children:
-    - inners:
-        rule: DStringInner
-        vec: true
-    - expressions:
-        rule: DStringExpression
-        vec: true
-StringInner:
-  children:
-    - literal:
-        build:
-          type: string
-          from: whole_pair
-DStringInner:
-  children:
-    - literal:
-        build: 
-          type: string
-          from: whole_pair
-DStringExpression:
-  children:
-    - expression
-BacktickString:
-  children:
-    - inners:
-        rule: BacktickInner
-        vec: true
-    - expressions:
-        rule: DStringExpression
-        vec: true
-BacktickInner:
-  children:
-    - literal:
-        build: 
-          type: string
-          from: whole_pair
-BooleanLiteral:
-  children:
-    - literal:
-        build: 
-          type: boolean
-          from: parse_whole_pair

src/parser/deimos.pest

@@ -30,10 +30,6 @@ Alias = { "alias" }
 True = { "true" }
 False = { "false" }
 Use = { "use" }
-Then = { "then" }
-Do = { "do" }
-End = { "end" }
-Companion = { "comp" }
 
 // Keywords: primitive types
 Byte = { "Byte" }
@@ -81,10 +77,6 @@ Keyword = {
     | True
     | False
     | Use
-    | Then
-    | Do
-    | End
-    | Companion
     | Byte
     | Short
     | Char
@@ -330,31 +322,22 @@ RefList = {
 
 CompilationUnit = {
       SOI
-    ~ ParentMod?
+    ~ ( Namespace ~ Semicolon )?
-    ~ ( UseStatement | ModuleLevelDeclaration )*
+    ~ ( UseStatement ~ Semicolon )*
+    ~ ModuleLevelDeclaration*
     ~ EOI
 }
 
-ParentMod = {
+Namespace = {
-      Mod
+      Ns
     ~ FullyQualifiedName
 }
 
 UseStatement = {
       Use
-    ~ UseStatementPrefix*
+    ~ Identifier
-    ~ UseStatementSuffix
+    ~ ( "::" ~ Identifier )*
-}
+    ~ ( "::" ~ ( Star | UseList ) )?
-
-UseStatementPrefix = {
-      Identifier
-    ~ "::"
-}
-
-UseStatementSuffix = {
-      Identifier
-    | Star
-    | UseList
 }
 
 UseList = {
@@ -370,12 +353,12 @@ ModuleLevelDeclaration = {
       Module
     | Interface
     | Class
-    | Function
+    | FunctionDefinition
     | PlatformFunction
 }
 
 InterfaceLevelDeclaration = {
-      CompanionModule
+      Module
     | Interface
     | Class
     | InterfaceFunction
@@ -385,12 +368,14 @@ InterfaceLevelDeclaration = {
 }
 
 ClassLevelDeclaration = {
-      CompanionModule
+      Module
     | Interface
     | Class
-    | Function
+    | FunctionDefinition
-    | OperatorFunction
+    | OperatorFunctionDefinition
     | PlatformFunction
+    | Property
+    | Field
 }
 
 // Main organizational constructs
@@ -399,15 +384,7 @@ Module = {
       Pub?
     ~ Mod
     ~ Identifier
-    ~ ModuleLevelDeclaration*
+    ~ "{" ~ ModuleLevelDeclaration* ~ "}"
-    ~ End
-}
-
-CompanionModule = {
-      Companion
-    ~ Mod
-    ~ ModuleLevelDeclaration*
-    ~ End
 }
 
 Interface = {
@@ -416,8 +393,7 @@ Interface = {
     ~ Identifier
     ~ GenericParameters?
     ~ ImplementsList?
-    ~ InterfaceLevelDeclaration*
+    ~ ( "{" ~ InterfaceLevelDeclaration* ~ "}" )?
-    ~ End
 }
 
 Class = {
@@ -427,14 +403,14 @@ Class = {
     ~ GenericParameters?
     ~ ClassConstructor?
     ~ ImplementsList?
-    ~ ClassLevelDeclaration*
+    ~ ( "{" ~ ClassLevelDeclaration* ~ "}" )?
-    ~ End
 }
 
 // Function constructs
 
-Function = {
+FunctionDefinition = {
       Pub?
+    ~ FunctionModifier?
     ~ Fn
     ~ GenericParameters?
     ~ Identifier
@@ -443,8 +419,9 @@ Function = {
     ~ FunctionBody
 }
 
-OperatorFunction = {
+OperatorFunctionDefinition = {
       Pub?
+    ~ FunctionModifier?
     ~ Op
     ~ GenericParameters?
     ~ Operator
@@ -455,16 +432,19 @@ OperatorFunction = {
 
 PlatformFunction = {
       Pub?
+    ~ FunctionModifier?
     ~ Platform
     ~ Fn
     ~ GenericParameters?
     ~ Identifier
     ~ Parameters
     ~ ReturnType
+    ~ ";"
 }
 
 InterfaceFunction = {
-      Fn
+      FunctionModifier?
+    ~ Fn
     ~ GenericParameters?
     ~ Identifier
     ~ Parameters
@@ -473,16 +453,18 @@ InterfaceFunction = {
 
 InterfaceDefaultFunction = {
       Def
+    ~ FunctionModifier?
     ~ Fn
     ~ GenericParameters?
     ~ Identifier
     ~ Parameters
-    ~ ReturnType?
+    ~ ReturnType
     ~ FunctionBody
 }
 
 InterfaceOperatorFunction = {
-      Op
+      FunctionModifier?
+    ~ Op
     ~ GenericParameters?
     ~ Operator
     ~ Parameters
@@ -491,20 +473,27 @@ InterfaceOperatorFunction = {
 
 InterfaceDefaultOperatorFunction = {
       Def
+    ~ FunctionModifier?
     ~ Op
     ~ GenericParameters?
     ~ Operator
     ~ Parameters
-    ~ ReturnType?
+    ~ ReturnType
     ~ FunctionBody
 }
 
-// Function Components
+FunctionModifier = {
+      Static
+    | Cons
+    | Mut ~ Ref
+    | Mut
+    | Ref
+}
 
 FunctionBody = {
       FunctionAliasBody
     | FunctionEqualsBody
-    | FunctionBlockBody
+    | BlockStatement
 }
 
 FunctionEqualsBody = {
@@ -517,23 +506,30 @@ FunctionAliasBody = {
     ~ Identifier
 }
 
-FunctionBlockBody = {
-      Statement*
-    ~ End
-}
-
 // Class constructs
 
 ClassConstructor = {
       "("
-    ~ Member
+    ~ DataMember
-    ~ ( "," ~ Member )*
+    ~ ( "," ~ DataMember )*
     ~ ")"
 }
 
-Member = {
+DataMember = {
-      Pub?
+      Property
-    ~ Mut?
+    | Field
+}
+
+Property = {
+      Mut?
+    ~ Identifier
+    ~ ":"
+    ~ TypeUse
+}
+
+Field = {
+      Mut?
+    ~ Fld
     ~ Identifier
     ~ ":"
     ~ TypeUse
@@ -541,14 +537,29 @@ Member = {
 
 // Statements
 
+BlockStatement = {
+      "{"
+    ~ Statement*
+    ~ Expression?
+    ~ "}"
+}
+
 Statement = {
-      VariableDeclaration
+      (
-    | AssignmentStatement
+          VariableDeclaration
-    | ExpressionStatement
+        | AssignmentStatement
-    | UseStatement
+        | CallStatement
-    | IfStatement
+        | ReturnStatement
-    | WhileStatement
+        | UseStatement
-    | ForStatement
+      )
+    ~ Semicolon
+    | (
+          BlockStatement
+        | IfElseStatement
+        | IfStatement
+        | WhileStatement
+        | ForStatement
+      )
 }
 
 VariableDeclaration = {
@@ -565,50 +576,63 @@ AssignmentStatement = {
     ~ Expression
 }
 
-ExpressionStatement = {
+CallStatement = { 
-      Expression
+      PrimaryExpression
+    ~ ObjectAccess?
+    ~ ParenthesesCall
+    ~ (
+          ObjectAccess
+        | ParenthesesCall
+        | PlusPlus
+        | MinusMinus
+      )*    
+}
+
+ReturnStatement = {
+      Return
+    ~ Expression?
 }
 
 IfStatement = {
-      IfClause
-    ~ IfElseIf*
-    ~ IfElse?
-    ~ End
-}
-
-IfClause = {
       If
+    ~ "("
     ~ Expression
-    ~ Then
+    ~ ")"
-    ~ Statement*
+    ~ BlockStatement
 }
 
-IfElseIf = {
+IfElseStatement = {
-      Else
+      IfStatement
-    ~ IfClause
+    ~ ElseIf*
+    ~ ElseBlock?
 }
 
-IfElse = {
+ElseIf = {
       Else
-    ~ Statement*
+    ~ IfStatement
+}
+
+ElseBlock = {
+      Else
+    ~ BlockStatement
 }
 
 WhileStatement = {
       While
+    ~ "("
     ~ Expression
-    ~ Do
+    ~ ")"
-    ~ Statement*
+    ~ BlockStatement
-    ~ End
 }
 
 ForStatement = {
       For
+    ~ "("
     ~ Identifier
     ~ In
     ~ Expression
-    ~ Do
+    ~ ")"
-    ~ Statement*
+    ~ BlockStatement
-    ~ End
 }
 
 // Expressions
@@ -619,22 +643,12 @@ Expression = {
 
 TernaryExpression = {
       OrExpression
-    ~ ( TernaryAlternatives )?
+    ~ ( 
-}
+          "?"
-
+        ~ Expression
-TernaryAlternatives = {
+        ~ ":"
-      TernaryTrueAlternative
+        ~ Expression
-    ~ TernaryFalseAlternative
+      )?
-}
-
-TernaryTrueAlternative = {
-      "?"
-    ~ Expression
-}
-
-TernaryFalseAlternative = {
-      ":"
-    ~ Expression
 }
 
 OrExpression = {
@@ -650,93 +664,52 @@ AndExpression = {
 ComparisonExpression = {
       ShiftExpression
     ~ (
-          ComparisonOperator
+          ( Greater | Less | GreaterEqual | LessEqual | EqualTo | NotEqualTo )
         ~ Expression
       )?
 }
 
-ComparisonOperator = {
-      Greater
-    | Less
-    | GreaterEqual
-    | LessEqual
-    | EqualTo
-    | NotEqualTo
-}
-
 ShiftExpression = {
       AdditiveExpression
-    ~ (
+    ~ ( ( LeftShift | RightShift ) ~ Expression )?
-          ShiftOperator
-        ~ Expression
-      )?
-}
-
-ShiftOperator = {
-      LeftShift
-    | RightShift
 }
 
 AdditiveExpression = {
       MultiplicativeExpression
     ~ (
-          AdditiveOperator
+          ( Add | Subtract )
         ~ Expression
       )?
 }
 
-AdditiveOperator = {
-      Add
-    | Subtract
-}
-
 MultiplicativeExpression = {
       PrefixExpression
     ~ (
-          MultiplicativeOperator
+          ( Multiply | Divide | Modulo )
         ~ Expression
       )?
 }
 
-MultiplicativeOperator = {
-      Multiply
-    | Divide
-    | Modulo
-}
-
 PrefixExpression = {
-      PrefixOperator*
+      ( 
+          Spread
+        | BorrowMut
+        | Borrow
+        | Mut
+        | Not
+        | Negative
+      )*
     ~ SuffixExpression
 }
 
-PrefixOperator = {
-      Spread
-    | Not
-    | Negative
-}
-
 SuffixExpression = {
       PrimaryExpression
-    ~ SuffixOperator*
+    ~ (
-}
+          ObjectAccess
-
+        | ParenthesesCall
-SuffixOperator = {
+        | PlusPlus
-      PlusPlus
+        | MinusMinus
-    | MinusMinus
+      )*
-    | ObjectProperty
-    | ObjectIndex
-    | Call
-}
-
-ObjectProperty = {
-      "."
-    ~ Identifier
-}
-
-ObjectIndex = {
-      "["
-    ~ Expression
-    ~ "]"
 }
 
 PrimaryExpression = {
@@ -752,13 +725,23 @@ ParenthesizedExpression = {
     ~ ")"
 }
 
-// Calls
+ObjectAccess = {
-
+      ( ObjectProperty | ObjectIndex )+
-Call = {
-      ParenthesesCall
-    | NonParenthesesCall
 }
 
+ObjectProperty = {
+      "."
+    ~ Identifier
+}
+
+ObjectIndex = {
+      "["
+    ~ Expression
+    ~ "]"
+}
+
+// Calls
+
 ParenthesesCall = {
       TurboFish?
     ~ "("
@@ -767,15 +750,6 @@ ParenthesesCall = {
     ~ Closure?
 }
 
-NonParenthesesCall = {
-      TurboFish?
-    ~ (
-          Closure
-        | ExpressionList
-        | ExpressionList ~ Closure
-      )
-}
-
 TurboFish = {
       "::"
     ~ GenericArguments
@@ -789,9 +763,13 @@ ExpressionList = {
 // Closure
 
 Closure = {
-      "{"
+      ( Cons | Mut )?
+    ~ Move?
+    ~ ClosureCaptures?
+    ~ "{"
     ~ ( ClosureParameters? ~ "->" )?
     ~ Statement*
+    ~ Expression?
     ~ "}"
 }
 
@@ -805,6 +783,19 @@ ClosureParameter = {
     ~ ( ":" ~ TypeUse )?
 }
 
+ClosureCaptures = {
+      "|"
+    ~ ClosureCapture
+    ~ ( "," ~ ClosureCapture )*
+    ~ "|"
+}
+
+ClosureCapture = {
+      Borrow*
+    ~ Mut?
+    ~ Identifier
+}
+
 // Literals
 
 Literal = {
@@ -823,7 +814,7 @@ IntLiteral = { NumberBase }
 
 LongLiteral = ${ NumberBase ~ "L" }
 
-DoubleLiteral = @{ DecimalBase ~ "." ~ DecimalBase}
+DoubleLiteral = ${ DecimalBase ~ "." ~ Digit+ }
 
 NumberBase = {
       BinaryBase
@@ -831,17 +822,18 @@ NumberBase = {
     | DecimalBase
 }
 
-DecimalBase = @{ '0'..'9'+ }
+DecimalBase = @{
+      "0"
+    | DecimalStartDigit ~ Digit*
+}
 
-BinaryBase = { "0b" ~ BinaryDigits }
+BinaryBase = @{ "0b" ~ Digit+ }
 
-BinaryDigits = @{ BinaryDigit+ }
+DecimalStartDigit = { '1'..'9' }
 
-BinaryDigit = { "0" | "1" }
+Digit = @{ '0'..'9'+ }
 
-HexadecimalBase = { "0x" ~ HexadecimalDigits }
+HexadecimalBase = @{ "0x" ~ HexadecimalDigit+ }
-
-HexadecimalDigits = @{ HexadecimalDigit+ }
 
 HexadecimalDigit = { '0'..'9' | 'a'..'f' }
 
@@ -873,7 +865,7 @@ DStringInner = @{ DStringChar+ }
 DStringChar = {
       !( "\"" | "\\" | "${" ) ~ ANY
     | "\\" ~ ( "\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t" | "$" )
-    | "\\" ~ "u" ~ ASCII_HEX_DIGIT{4}
+    | "\\" ~ ( "u" ~ ASCII_HEX_DIGIT{4} )
 }
 
 DStringExpression = {
@@ -892,9 +884,9 @@ BacktickString = {
 BacktickInner = @{ BacktickStringChar+ }
 
 BacktickStringChar = {
-      !( "`" | "\\" | "${" ) ~ ANY
+      !( "\\`" | "\\" | "${" ) ~ ANY
     | "\\" ~ ( "`" | "\\" | "/" | "b" | "f" | "n" | "r" | "t" | "$" )
-    | "\\" ~ "u" ~ ASCII_HEX_DIGIT{4}
+    | "\\" ~ ( "u" ~ ASCII_HEX_DIGIT{4} )
 }
 
 BooleanLiteral = { True | False }