Starting over with types

This commit is contained in:
greg 2018-02-21 02:31:28 -08:00
parent 7b4f69dce5
commit c674148772
2 changed files with 59 additions and 2 deletions

View File

@ -2,10 +2,11 @@ use itertools::Itertools;
use schala_lib::{ProgrammingLanguageInterface, EvalOptions, TraceArtifact, ReplOutput}; use schala_lib::{ProgrammingLanguageInterface, EvalOptions, TraceArtifact, ReplOutput};
mod parsing; mod parsing;
mod type_check; //mod type_check;
mod typechecking;
mod eval; mod eval;
use self::type_check::{TypeContext}; use self::typechecking::{TypeContext};
pub struct Schala { pub struct Schala {
state: eval::ReplState, state: eval::ReplState,
@ -61,6 +62,18 @@ impl ProgrammingLanguageInterface for Schala {
} }
}; };
match self.type_context.type_check_ast(&ast) {
Ok(ty) => {
output.add_artifact(TraceArtifact::new("type_check", format!("{:?}", ty)));
},
Err(msg) => {
output.add_artifact(TraceArtifact::new("type_check", msg));
output.add_output(format!("Type error"));
return output;
}
}
/*
self.type_context.add_symbols(&ast); self.type_context.add_symbols(&ast);
if options.debug_symbol_table { if options.debug_symbol_table {
@ -78,6 +91,7 @@ impl ProgrammingLanguageInterface for Schala {
return output; return output;
} }
} }
*/
let evaluation_outputs = self.state.evaluate(ast); let evaluation_outputs = self.state.evaluate(ast);
let text_output: String = evaluation_outputs.into_iter().intersperse(format!("\n")).collect(); let text_output: String = evaluation_outputs.into_iter().intersperse(format!("\n")).collect();

View File

@ -0,0 +1,43 @@
use std::rc::Rc;
use schala_lang::parsing;
pub struct TypeContext { }
#[derive(Debug, PartialEq)]
pub enum Type {
Unit,
Void
}
type TypeResult<T> = Result<T, String>;
impl TypeContext {
pub fn new() -> TypeContext {
TypeContext { }
}
pub fn type_check_ast(&mut self, ast: &parsing::AST) -> TypeResult<Type> {
use self::Type::*;
let mut ret_type = Unit;
for statement in ast.0.iter() {
ret_type = self.type_check_statement(statement)?;
}
Ok(ret_type)
}
fn type_check_statement(&mut self, statement: &parsing::Statement) -> TypeResult<Type> {
use self::parsing::Statement::*;
match statement {
&ExpressionStatement(ref expr) => self.type_check_expression(expr),
&Declaration(ref decl) => self.type_check_declaration(decl),
}
}
fn type_check_declaration(&mut self, decl: &parsing::Declaration) -> TypeResult<Type> {
use self::Type::*;
Ok(Unit)
}
fn type_check_expression(&mut self, expr: &parsing::Expression) -> TypeResult<Type> {
use self::Type::*;
Ok(Void)
}
}