a complete mess of types

[amitu]

So identifiers, types etc making my head spin quite a bit, and here is the mess I have created so far.

fastn_section::Span

This is our lowest level type, it actually represents any (contiguous) span of text found source. It does not keep track which module did the span come from though.

pub struct Span {
    inner: arcstr::Substr, // this is a 32-byte struct.
}

fastn_section::Identifier

This is our main "identifier" type.

pub struct Identifier {
    pub name: fastn_section::Span,
}

This is also type aliased as fastn_unresolved::Identifier.

fastn_unresolved::IdentifierReference

This is the "natural" identifier. This should be used when we are referencing something tho, not when we are defining things.

pub enum IdentifierReference {
    // foo
    Local(Identifier),
    // bar.foo: module = bar, name: foo
    Imported { module: Module, name: Identifier },
    // bar#foo: component using the absolute path.
    Absolute { module: Module, name: Identifier },
}

The definition should be "simple" identifier, meaning no ./# in it etc, and I am currently thinking of using fastn_unresolved::Identifier for that.

Maybe we should rename this to fastn_unresolved::PlainIdentifier or fastn_unresolved::SimpleIdentifier.

fastn_unresolved::{Symbol, Module}

These are interned string based types.

pub struct Symbol {
    // 8 bytes
    /// this store the <package>/<module>#<name> of the symbol
    interned: string_interner::DefaultSymbol, // u32
    /// length of the <package> part of the symbol
    package_len: u16,
    /// length of the <module> part of the symbol
    module_len: u16,
}

pub struct Module {
    // 6 bytes
    /// this store the <package>/<module>#<name> of the symbol
    interned: string_interner::DefaultSymbol, // u32
    /// length of the <package> part of the symbol
    package_len: u16,
}

fastn_unresolved::{PackageName, ModuleName}

These types were earlier used before we had interned string based stuff.

pub struct PackageName(pub Identifier);

pub struct ModuleName {
    pub name: Identifier,
    pub package: PackageName,
}

I think they have to be deleted in favour of fastn_unresolved::{Symbol, Module}.

fastn_unresolved::Kind

pub enum Kind {
    Integer,
    Decimal,
    String,
    Boolean,
    Option(Box<Kind>),
    // TODO: Map(Kind, Kind),
    List(Box<Kind>),
    Caption(Box<Kind>),
    Body(Box<Kind>),
    CaptionOrBody(Box<Kind>),
    // TODO: Future(Kind),
    // TODO: Result(Kind, Kind),
    Custom(Symbol),
}

fastn_section::AliasableIdentifier

pub struct AliasableIdentifier {
    pub name: fastn_section::Span,
    pub alias: Option<fastn_section::Span>,
}

This is decent to keep around, just the inner values have to be switched to SimpleIdentifiers instead of spans, as both name and alias are not allowed to contain anything special.

fastn_section::{PackageName, ModuleName}

pub struct PackageName {
    pub name: fastn_section::Span,
    // for foo.com, the alias is `foo` (the first part before the first dot)
    // TODO: unless it is `www`, then its the second part
    pub alias: fastn_section::Span,
}

pub struct ModuleName {
    pub package: PackageName,
    pub name: AliasableIdentifier,
    pub path: Vec<Identifier>, // rest of the path
}

I feel these should be deleted in favour of the intern based fastn_unresolved::Module. There is one place where we expect a package name without module name, which is the fastn.package declaration. Similarly in fastn.dependency and fastn.auto-import we expect packages and modules to be aliasable.

Both these types are only used when parsing FASTN.ftd, which we are keeping in fastn-core, so they should be removed from fastn_section/fastn_unresolved.

fastn_section:: QualifiedIdentifier

pub struct QualifiedIdentifier {
    // the part comes before `#`
    pub module: Option<ModuleName>,
    // the part comes after `#`
    pub terms: Vec<Identifier>,
}

This too I added pretty early in 0.5 folder, and I am no longer sure we need it. The terms being available as Vec is useless. fastn_unresolved::Symbol is good enough. Terms did allow us to do foo.bar.baz tho, which we do not how to handle, and this type is the only one that has any handling of that.

fastn_section::Kind

It's not really an identifier, but it internally refers to identifier, and currently they are fastn_section::QualifiedIdentifier.

pub struct Kind {
    // only kinded section / header can have doc
    pub doc: Option<fastn_section::Span>,
    pub visibility: Option<fastn_section::Spanned<fastn_section::Visibility>>,
    pub name: fastn_section::QualifiedIdentifier,
    // during parsing, we can encounter `foo<>`, which needs to be differentiated from `foo`
    // therefore we are using `Option<Vec<>>` here
    pub args: Option<Vec<Kind>>,
}