trudging through the snow

2025-05-06 23:27:30 -04:00
parent 9368d6dcd0
commit 0016ede873
29 changed files with 1375 additions and 1085 deletions
@@ -1,9 +1,37 @@
-use super::{FnInst, ResErr, StructInst, Type, UInstrInst, UInstruction};
+//! all main IR Upper data structures stored in UProgram
+
+use super::{FnInst, ResErr, StructInst, Type, UInstrInst, UInstruction, UProgram};
 use crate::{
    common::FileSpan,
    ir::{Len, ID},
 };
-use std::{collections::HashMap, fmt::Debug};
+use std::{
+    collections::HashMap,
+    fmt::{Debug, Display},
+};
+
+pub trait ResStage {
+    type Var;
+    type Func;
+    type Struct;
+    type Type;
+}
+
+pub struct Unresolved;
+impl ResStage for Unresolved {
+    type Var = IdentID;
+    type Func = IdentID;
+    type Struct = IdentID;
+    type Type = IdentID;
+}
+
+pub struct Resolved;
+impl ResStage for Resolved {
+    type Var = VarID;
+    type Func = FnInst;
+    type Struct = StructInst;
+    type Type = TypeID;
+}

 pub type NamePath = Vec<String>;

@@ -16,7 +44,6 @@ pub type StructID = ID<UStruct>;
 pub type DataID = ID<UData>;
 pub type ModID = ID<UModule>;

-#[derive(Clone)]
 pub struct UFunc {
    pub name: String,
    pub origin: Origin,
@@ -26,12 +53,12 @@ pub struct UFunc {
    pub instructions: Vec<UInstrInst>,
 }

-#[derive(Clone)]
 pub struct StructField {
    pub ty: TypeID,
+    pub origin: Origin,
+    // pub vis: Visibility
 }

-#[derive(Clone)]
 pub struct UStruct {
    pub name: String,
    pub origin: Origin,
@@ -39,13 +66,11 @@ pub struct UStruct {
    pub gargs: Vec<GenericID>,
 }

-#[derive(Clone)]
 pub struct UGeneric {
    pub name: String,
    pub origin: Origin,
 }

-#[derive(Clone)]
 pub struct UVar {
    pub name: String,
    pub origin: Origin,
@@ -54,43 +79,53 @@ pub struct UVar {
    pub children: HashMap<String, VarID>,
 }

-/// eg. a::b::c::<T,U>.d.e
-#[derive(Clone, Debug)]
+/// a generic identifier for all (identifiable) kinds
+/// eg. a::b::c.d.e
+/// or a::Result<T,_>
 pub struct UIdent {
    pub status: IdentStatus,
    pub origin: Origin,
 }

-#[derive(Clone, Debug)]
 pub enum IdentStatus {
-    Var(VarID),
-    Struct(StructInst),
-    Fn(FnInst),
-    Type(TypeID),
+    Res(Res),
    Unres {
-        path: ModPath,
-        mem: MemberID,
-        gargs: Vec<TypeID>,
-        fields: Vec<MemberID>,
+        base: ResBase,
+        path: Vec<MemberIdent>,
    },
-    PartialVar {
-        id: VarID,
-        fields: Vec<MemberID>,
-    },
-    Failed(ResErr),
+    Failed(Option<ResErr>),
    Cooked,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MemberID {
+pub struct MemberIdent {
+    pub ty: MemberTy,
    pub name: String,
+    pub gargs: Vec<TypeID>,
    pub origin: Origin,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ModPath {
-    pub id: ModID,
-    pub path: Vec<MemberID>,
+#[derive(Clone, Copy)]
+pub enum MemberTy {
+    Member,
+    Field,
+}
+
+impl MemberTy {
+    pub fn sep(&self) -> &'static str {
+        match self {
+            MemberTy::Member => "::",
+            MemberTy::Field => ".",
+        }
+    }
+}
+
+impl Display for MemberTy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            MemberTy::Member => "member",
+            MemberTy::Field => "field",
+        })
+    }
 }

 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
@@ -110,25 +145,163 @@ pub struct UData {
 pub struct UModule {
    pub name: String,
    pub members: HashMap<String, Member>,
-    pub children: HashMap<String, ModID>,
    pub parent: Option<ModID>,
+    pub func: FnID,
 }

 #[derive(Clone)]
 pub struct Member {
-    pub id: MemberTy,
+    pub id: MemberID,
    // pub visibility: Visibility
 }

 #[derive(Clone)]
-pub enum MemberTy {
+pub enum MemberID {
    Fn(FnID),
    Struct(StructID),
    Var(VarID),
+    Module(ModID),
+    Type(TypeDef),
+}
+
+#[derive(Clone)]
+pub struct TypeDef {
+    pub gargs: Vec<GenericID>,
+    pub ty: TypeID,
+}
+
+impl MemberID {
+    pub fn kind(&self) -> KindTy {
+        match self {
+            MemberID::Fn(_) => KindTy::Fn,
+            MemberID::Struct(_) => KindTy::Struct,
+            MemberID::Var(_) => KindTy::Var,
+            MemberID::Module(_) => KindTy::Module,
+            MemberID::Type(_) => KindTy::Type,
+        }
+    }
+    pub fn display_str(&self, p: &UProgram) -> String {
+        let name = match self {
+            MemberID::Var(id) => &p.vars[id].name,
+            MemberID::Fn(id) => &p.fns[id].name,
+            MemberID::Struct(id) => &p.structs[id].name,
+            MemberID::Module(id) => &p.modules[id].name,
+            MemberID::Type(id) => &p.type_name(id),
+        };
+        format!("{} '{}'", self.kind(), name)
+    }
 }

 pub type Origin = FileSpan;

+// "effective" (externally visible) kinds
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum KindTy {
+    Type,
+    Var,
+    Struct,
+    Fn,
+    Module,
+    Generic,
+}
+
+impl Display for KindTy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            KindTy::Type => "type",
+            KindTy::Var => "variable",
+            KindTy::Fn => "function",
+            KindTy::Struct => "struct",
+            KindTy::Module => "module",
+            KindTy::Generic => "generic",
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Res {
+    Var(VarID),
+    Fn(FnInst),
+    Struct(StructInst),
+    Type(TypeID),
+    Generic(GenericID),
+    Module(ModID),
+}
+
+impl Res {
+    pub fn kind(&self) -> KindTy {
+        match self {
+            Res::Var(..) => KindTy::Var,
+            Res::Fn(..) => KindTy::Fn,
+            Res::Struct(..) => KindTy::Struct,
+            Res::Type(..) => KindTy::Type,
+            Res::Module(..) => KindTy::Module,
+            Res::Generic(..) => KindTy::Generic,
+        }
+    }
+
+    pub fn display_str(&self, p: &UProgram) -> String {
+        let name = match self {
+            Res::Var(id) => &p.vars[id].name,
+            Res::Fn(fi) => &p.fns[fi.id].name,
+            Res::Struct(si) => &p.structs[si.id].name,
+            Res::Type(id) => &p.type_name(id),
+            Res::Generic(id) => &p.generics[id].name,
+            Res::Module(id) => &p.modules[id].name,
+        };
+        format!("{} '{}'", self.kind(), name)
+    }
+}
+
+#[derive(Clone)]
+pub enum ResBase {
+    Unvalidated(MemRes),
+    Validated(Res),
+}
+
+impl ResBase {
+    pub fn display_str(&self, p: &UProgram) -> String {
+        match self {
+            ResBase::Unvalidated(uv) => uv.display_str(p),
+            ResBase::Validated(res) => res.display_str(p),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct MemRes {
+    pub mem: Member,
+    pub origin: Origin,
+    pub gargs: Vec<TypeID>,
+}
+
+impl MemRes {
+    pub fn display_str(&self, p: &UProgram) -> String {
+        self.mem.id.display_str(p)
+    }
+}
+
+impl IdentID {
+    pub fn var(&self, p: &UProgram) -> Option<VarID> {
+        match p.idents[self].status {
+            IdentStatus::Res(Res::Var(id)) => Some(id),
+            _ => None,
+        }
+    }
+    pub fn fun<'a>(&self, p: &'a UProgram) -> Option<&'a FnInst> {
+        match &p.idents[self].status {
+            IdentStatus::Res(Res::Fn(i)) => Some(&i),
+            _ => None,
+        }
+    }
+    pub fn struc<'a>(&self, p: &'a UProgram) -> Option<&'a StructInst> {
+        match &p.idents[self].status {
+            IdentStatus::Res(Res::Struct(i)) => Some(&i),
+            _ => None,
+        }
+    }
+}
+
 impl UFunc {
    pub fn flat_iter(&self) -> impl Iterator<Item = &UInstrInst> {
        InstrIter::new(self.instructions.iter())
@@ -162,4 +335,3 @@ impl<'a> Iterator for InstrIter<'a> {
        Some(next)
    }
 }
-