stuff i guess

src/diagnostic.rs

@@ -1,9 +1,6 @@
+use crate::scanner::lexeme::Token;
 use std::collections::HashSet;
 
-use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};
-
-use crate::{files::Files, scanner::lexeme::Token};
-
 pub struct PassResult<'a, T> {
     pub result: T,
     pub diagnostics: HashSet<Diagnostic<'a>>,

src/main.rs

@@ -1,19 +1,14 @@
 use anyhow::{Ok, Result};
-use codespan_reporting::term::{
-    self,
-    termcolor::{ColorChoice, StandardStream},
-};
-
-use diagnostic::{Diagnostic, Snippet};
 use files::Files;
-use std::{collections::HashSet, env::args, fs::read};
+use std::{env::args, fs::read};
 use transpiler::{javascript::JavaScriptTranspiler, Transpiler};
 
 pub mod diagnostic;
 pub mod files;
 pub mod parser;
 pub mod scanner;
 pub mod transpiler;
+pub mod typechecker;
 
 fn main() -> Result<()> {
     let args: Vec<String> = args().skip(1).collect();
@@ -55,9 +50,7 @@ fn main() -> Result<()> {
     let mut parser = parser::Parser::new(&scanner_pass.result);
     let parser_pass = parser.parse().unwrap();
 
-    parser.print_diagnostics(&files);
-
-    let mut transpiled = JavaScriptTranspiler::transpile(&parser_pass);
+    let transpiled = JavaScriptTranspiler::transpile(&parser_pass);
 
     println!("{}", transpiled);
 

src/parser/ast.rs

@@ -3,13 +3,55 @@ use std::{
     hash::Hash,
 };
 
-use crate::scanner::lexeme::Token;
+use crate::diagnostic::Range;
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum Symbol {
-    Expression(Expression),
-    Statement(Statement),
-    Type(Type),
+pub enum Symbol<'a> {
+    Expression(ExpressionSymbol<'a>),
+    Statement(StatementSymbol<'a>),
+    Type(TypeSymbol<'a>),
+}
+
+impl Symbol<'_> {
+    pub fn range(&self) -> &Range {
+        match self {
+            Symbol::Expression(expression) => &expression.range,
+            Symbol::Statement(statement) => &statement.range,
+            Symbol::Type(typest) => &typest.range,
+        }
+    }
+}
+
+pub struct ExpressionSymbol<'a> {
+    pub range: Range<'a>,
+    pub value: Expression,
+}
+
+impl<'a> ExpressionSymbol<'a> {
+    pub fn new(value: Expression, range: Range<'a>) -> Self {
+        Self { value, range }
+    }
+}
+
+pub struct StatementSymbol<'a> {
+    pub range: Range<'a>,
+    pub value: Satement,
+}
+
+impl<'a> StatementSymbol<'a> {
+    pub fn new(value: Satement, range: Range<'a>) -> Self {
+        Self { value, range }
+    }
+}
+
+pub struct TypeSymbol<'a> {
+    pub range: Range<'a>,
+    pub value: Type,
+}
+
+impl<'a> TypeSymbol<'a> {
+    pub fn new(value: Type, range: Range<'a>) -> Self {
+        Self { value, range }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -27,8 +69,8 @@ pub enum Expression {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Statement {
-    Block(Vec<Statement>),
+pub enum Satement {
+    Block(Vec<Expression>),
     Declaration(String, Option<Type>, Expression),
     Expression(Expression),
     Struct(String, HashSet<FieldSignature>),
@@ -39,10 +81,18 @@ pub enum Statement {
     Implementation(String, String, HashSet<Function>),
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Type {
+    Void,
+    Symbol(String),
+    Array(Box<Type>),
+    Tuple(HashMap<String, Type>),
+}
+
 #[derive(Debug, Clone)]
 pub struct Function {
     pub signature: FunctionSignature,
-    pub body: Box<Statement>,
+    pub body: Box<Satement>,
 }
 
 impl PartialEq for Function {
@@ -109,11 +159,3 @@ pub enum BinaryOperation {
     Times,
     Divide,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Type {
-    Void,
-    Symbol(String),
-    Array(Box<Type>),
-    Tuple(HashMap<String, Type>),
-}

src/parser/expression/functions.rs

@@ -1,10 +1,8 @@
-use std::collections::HashMap;
-
 use crate::{
     parser::{
         ast::Expression,
         lookup::{BindingPower, Lookup},
-        macros::{expect_token, expect_value, optional_token},
+        macros::{expect_token, optional_token},
     },
     scanner::lexeme::TokenType,
 };

src/parser/lookup.rs

@@ -24,7 +24,7 @@ pub enum BindingPower {
 
 pub type TypeHandler<'a> = fn(&mut Parser<'a>) -> ParseResult<'a, Type>;
 pub type LeftTypeHandler<'a> = fn(&mut Parser<'a>, Type, BindingPower) -> ParseResult<'a, Type>;
-pub type StatementHandler<'a> = fn(&mut Parser<'a>) -> ParseResult<'a, Statement>;
+pub type StatementHandler<'a> = fn(&mut Parser<'a>) -> ParseResult<'a, Satement>;
 pub type ExpressionHandler<'a> = fn(&mut Parser<'a>) -> ParseResult<'a, Expression>;
 pub type LeftExpressionHandler<'a> =
     fn(&mut Parser<'a>, Expression, BindingPower) -> ParseResult<'a, Expression>;

src/parser/macros.rs

@@ -22,7 +22,7 @@ macro_rules! expect_token {
                         format!("Expected {} here", TokenType::$token),
                     ))
                     .with_note(format!(
-                        "Expected {}, but got {} instead",
+                        "Expected {}, but found {} instead",
                         TokenType::$token,
                         token.token_type
                     )),
@@ -88,8 +88,12 @@ macro_rules! either_token {
                             "Unexpected token",
                         ))
                         .with_note(format!(
-                            "Expected one of {:?}, but got {} instead",
-                            vec![ $(TokenType::$token),* ],
+                            "Expected {}, but found {} instead",
+                            vec![ $(TokenType::$token),* ]
+                                .iter()
+                                .map(|t| format!("{}", t))
+                                .collect::<Vec<String>>()
+                                .join(" or "),
                             token.token_type
                         )),
                 )

src/parser/mod.rs

@@ -1,9 +1,5 @@
-use crate::{
-    diagnostic::{Diagnostic, PassResult},
-    files::Files,
-    scanner::lexeme::{Token, TokenType, TokenValue},
-};
-use ast::{Statement, Symbol};
+use crate::{diagnostic::Diagnostic, files::Files, scanner::lexeme::Token};
+use ast::{Satement, StatementSymbol, Symbol};
 use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};
 use lookup::Lookup;
 use std::collections::HashSet;
@@ -34,7 +30,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse(&mut self) -> ParseResult<'a, Symbol> {
+    pub fn parse(&mut self) -> ParseResult<'a, StatementSymbol> {
         let mut statements = Vec::new();
         let mut panic_mode = false;
 
@@ -58,7 +54,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok(Symbol::Statement(Statement::Block(statements)))
+        Ok(StatementSymbol::new(Satement::Block(statements)))
     }
 
     pub(crate) fn peek(&self) -> Option<&Token<'a>> {
@@ -70,10 +66,6 @@ impl<'a> Parser<'a> {
         self.tokens.get(self.cursor - 1)
     }
 
-    pub(crate) fn peek_next(&self) -> Option<&Token<'a>> {
-        self.tokens.get(self.cursor + 1)
-    }
-
     pub(crate) fn has_tokens(&self) -> bool {
         self.cursor < self.tokens.len()
     }

src/parser/statement/enums.rs

@@ -1,14 +1,13 @@
-use std::collections::{HashMap, HashSet};
-
 use crate::{
     parser::{
         ast::{EnumMember, Statement},
-        lookup::{BindingPower, Lookup},
-        macros::{expect_token, expect_value, optional_token, warn_unneeded_token},
-        typest, ParseResult, Parser,
+        lookup::Lookup,
+        macros::{expect_token, expect_value, optional_token},
+        ParseResult, Parser,
     },
     scanner::lexeme::TokenType,
 };
+use std::collections::HashSet;
 
 use super::variables;
 

src/parser/statement/structs.rs

@@ -1,15 +1,14 @@
+use super::variables;
 use crate::{
     parser::{
         ast::{FieldSignature, Statement},
-        lookup::{BindingPower, Lookup},
+        lookup::Lookup,
         macros::{expect_token, expect_value, optional_token},
-        typest, ParseResult, Parser,
+        ParseResult, Parser,
     },
     scanner::lexeme::TokenType,
 };
-use std::collections::{HashMap, HashSet};
-
-use super::variables;
+use std::collections::HashSet;
 
 pub fn register(lookup: &mut Lookup) {
     lookup.add_statement_handler(TokenType::Struct, parse_struct);

src/parser/statement/traits.rs

@@ -2,8 +2,8 @@ use std::collections::HashSet;
 
 use crate::{
     parser::{
-        ast::{FieldSignature, Function, Statement},
-        lookup::{BindingPower, Lookup},
+        ast::{Function, Statement},
+        lookup::Lookup,
         macros::{either_token, expect_token, expect_value},
         ParseResult, Parser,
     },

src/parser/typest/mod.rs

@@ -5,7 +5,7 @@ use crate::{
 
 use super::{
     ast::Type,
-    lookup::{self, BindingPower, Lookup},
+    lookup::{BindingPower, Lookup},
     macros::{expect_token, expect_value},
     ParseResult, Parser,
 };

src/transpiler/javascript/expressions.rs

@@ -66,10 +66,10 @@ fn transpile_struct_initializer(_name: &str, fields: &HashMap<String, Expression
     format!("{{ {} }}", fields)
 }
 
-fn transpile_function_call(name: &str, parameters: &Vec<Expression>) -> String {
+fn transpile_function_call(name: &str, parameters: &[Expression]) -> String {
     let parameters = parameters
         .iter()
-        .map(|parameter| transpile(parameter))
+        .map(transpile)
         .collect::<Vec<String>>()
         .join(", ");
 

src/transpiler/javascript/mod.rs

@@ -1,7 +1,6 @@
 use super::Transpiler;
 use crate::parser::ast::Symbol;
-use anyhow::Result;
-use deno_core::{JsRuntime, RuntimeOptions};
+use deno_core::JsRuntime;
 
 pub mod expressions;
 pub mod statements;

src/transpiler/javascript/statements.rs

@@ -22,10 +22,10 @@ pub fn transpile(statement: &Statement) -> String {
     }
 }
 
-fn transpile_block(block: &Vec<Statement>) -> String {
+fn transpile_block(block: &[Statement]) -> String {
     block
         .iter()
-        .map(|statement| transpile(statement))
+        .map(transpile)
         .collect::<Vec<String>>()
         .join("\n")
 }
@@ -43,11 +43,11 @@ fn transpile_expression(expression: &Expression) -> String {
     format!("{};", expression)
 }
 
-fn transpile_struct(name: &String, fields: &HashSet<FieldSignature>) -> String {
+fn transpile_struct(name: &str, fields: &HashSet<FieldSignature>) -> String {
     "".to_string()
 }
 
-fn transpile_enum(name: &String, members: &HashSet<EnumMember>) -> String {
+fn transpile_enum(name: &str, members: &HashSet<EnumMember>) -> String {
     "".to_string()
 }
 

src/typechecker/mod.rs

@@ -0,0 +1,7 @@
+use std::collections::HashSet;
+
+use crate::{diagnostic::Diagnostic, parser::ast::Symbol};
+
+pub fn check(ast: &Symbol) -> Result<(), HashSet<Diagnostic>> {
+    Ok(())
+}