schala/schala-lang/language/src/scope_resolution.rs

use std::rc::Rc;

use crate::symbol_table::{ScopeSegment, ScopeSegmentKind, FullyQualifiedSymbolName};
use crate::ast::*;

pub struct ScopeResolver {
}

impl ScopeResolver {
  pub fn new() -> ScopeResolver {
    ScopeResolver { }
  }
  pub fn resolve(&mut self, ast: &mut AST) -> Result<(), String> {
    println!("Resolving scopes - nothing so far!");
    for statement in ast.0.iter_mut() {
      match statement.mut_node() {
        Statement::Declaration(ref mut decl) => self.decl(decl),
        Statement::ExpressionStatement(ref mut expr) => self.expr(expr),
      }?;
    }
    Ok(())
  }

  fn decl(&mut self, decl: &mut Declaration) -> Result<(), String> {
    match decl {
      Declaration::Binding { expr, .. } => self.expr(expr),
      _ => Ok(()),
    }
  }

  fn expr(&mut self, expr: &mut Meta<Expression>) -> Result<(), String> {
    match &expr.node().kind {

      //TODO this needs to fully recurse
      ExpressionKind::Value(qualified_name) => {
        //TODO fill this out
        let fqsn = lookup_name_in_scope(&qualified_name);
        expr.fqsn = Some(fqsn);
      },
      _ => ()
    };
    Ok(())
  }
}

//TODO this is incomplete
fn lookup_name_in_scope(sym_name: &QualifiedName) -> FullyQualifiedSymbolName {
  let QualifiedName(vec) = sym_name;
  let len = vec.len();
  let new_vec: Vec<ScopeSegment> = vec.iter().enumerate().map(|(i, name)| {
    let kind = if i == (len - 1) {
      ScopeSegmentKind::Terminal
    } else {
      ScopeSegmentKind::Type
    };
    ScopeSegment { name: name.clone(), kind }
  }).collect();
   FullyQualifiedSymbolName(new_vec)
}

#[cfg(test)]
mod tests {
  #[test]
  fn basic_scope() {

  }
}