Assignment and variable parsing

Author: jmintb

shell.nix

@@ -6,22 +6,9 @@ pkgs.mkShell {
     rustfmt 
     clippy 
     just 
-    kube3d 
     openssl 
     pkgconfig 
-    python310Packages.ipython
-    protobuf
-    kustomize
-    kubectl
-    operator-sdk
-    postgresql
-    s3cmd
-    minio-client
-    argo
-    python310Packages.mlflow
-    kubernetes-helm
-    grpcurl
-    sass
+    rust-analyzer
   ];
 
   # Certain Rust tools won't work without this

src/main.rs

@@ -1,70 +1,91 @@
-use pest::Parser;
+use pest::{iterators::Pair, Parser};
 use pest_derive::{self, Parser};
 
 #[derive(Parser)]
 #[grammar = "typed_script.pest"]
 struct TSParser;
 
+#[derive(Debug)]
 pub enum TSExpression {
-    Value(TSValue)
+    Value(TSValue),
 }
 
+#[derive(Debug)]
 pub enum TSValue {
-   String,
-   Number,
-   Boolean,
+    String(String),
+    Variable(String),
+    Number,
+    Boolean,
 }
 
+#[derive(Debug)]
 pub enum TSType {
     String,
     Number,
-    Boolean
+    Boolean,
 }
 
+#[derive(Debug)]
 pub struct TSIdentifier(String);
 
+#[derive(Debug)]
 pub enum TSAST {
     Value(TSValue),
     Expression(TSExpression),
-    Assignment(TSIdentifier, TSExpression) 
+    Assignment(TSIdentifier, TSExpression),
 }
 
+#[derive(Debug)]
 pub enum TypedAst {
     Value(TSValue, TSType),
-    Expression(TSExpression, TSType),
-    Assignment(TSIdentifier, TSExpression, TSType) 
+    Expression(TSExpression),
+    Assignment(TSIdentifier, TSExpression),
 }
 
-
 fn main() {
-    let parsed_res = TSParser::parse(Rule::program, "let myvar = \"test\";").unwrap();
-    
-    let mut ast: Vec<TSAST> = vec![];
-
-    for rule in parsed_res{
-       match rule.as_rule(){
-            Rule::program => println!("{}", rule),
-            Rule::expression => println!("{}", rule),
-            Rule::assignment => println!("{}", rule),
-            _ => println!("{}", rule)
-        }
+    let parsed_res = TSParser::parse(Rule::program, "let myvar = \"test\"; myvar").unwrap();
+
+    let mut ast: Vec<TypedAst> = vec![];
+
+    for rule in parsed_res {
+        let node = match rule.as_rule() {
+            Rule::program => todo!(),
+            Rule::expression => TypedAst::Expression(parse_expression(rule).unwrap()),
+            Rule::assignment => parse_assignment(rule).unwrap(),
+            _ => continue,
+        };
+
+        ast.push(node);
     }
 
+    println!("ast {:?}", ast);
 }
 
-fn parse_assignment(assignment: Rule::assignment) -> Result<TAST, Box<dyn std::error::Error>> {
-
+fn parse_assignment(assignment: Pair<Rule>) -> Result<TypedAst, Box<dyn std::error::Error>> {
     let mut inner_rules = assignment.into_inner();
 
-    inner_rules.next();
-
     let identifier = inner_rules.next().unwrap();
-    
-    inner_rules.next();
 
     let expression = inner_rules.next().unwrap();
 
-    println!("id: {identifier}, exp: {expression} ");
+    let expression = parse_expression(expression);
+
+    let assignment = TypedAst::Assignment(
+        TSIdentifier(identifier.as_str().into()),
+        expression.unwrap(),
+    );
+
+    Ok(assignment)
+}
+
+fn parse_expression(expression: Pair<Rule>) -> Result<TSExpression, Box<dyn std::error::Error>> {
+    let mut inner_rules = expression.into_inner().next().unwrap();
+
+    let typed_exp = match inner_rules.as_rule() {
+        Rule::string => TSExpression::Value(TSValue::String(inner_rules.as_str().into())),
+        Rule::identifier => TSExpression::Value(TSValue::Variable(inner_rules.as_str().into())),
+        _ => todo!(),
+    };
 
-    todo!()
+    Ok(typed_exp)
 }

src/typed_script.pest

@@ -1,17 +1,18 @@
 number = { ASCII_DIGIT+ }
 
+WHITESPACE = _{ " " }
 string = { "\""	~ inner ~ "\"" }
 
 identifier = {
 	ASCII_ALPHA+
 }
 
-assignment = { "let " ~ identifier  ~ " = " ~  expression ~ ";" }
+assignment = { "let " ~ identifier  ~ "=" ~  expression  }
 
 inner = @{ char* }
 
 expression = {
-	number | string
+	 number | string | identifier  
 }
 
 char = {
@@ -20,7 +21,7 @@ char = {
     | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})
 }
 
-stmt = _{ expression | assignment }
+stmt = _{ assignment | expression  }
 
-program = _{ SOI ~ "\n"* ~ (stmt ~ "\n"+) * ~ stmt? ~ EOI }
+program = _{ SOI ~ "\n"* ~ (stmt ~ ";") * ~ stmt? ~ EOI }