cl_typeck/
lib.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
//! # The Conlang Type Checker
//!
//! As a statically typed language, Conlang requires a robust type checker to enforce correctness.
//!
//! This crate is a major work-in-progress.
//!
//! # The [Table](table::Table)™
//! A directed graph of nodes and their dependencies.
//!
//! Contains [item definitions](handle) and [type expression](type_expression) information.
//!
//! *Every* item is itself a module, and can contain arbitrarily nested items
//! as part of the item graph
//!
//! The table, additionally, has some queues for use in external algorithms,
//! detailed in the [stage] module.
//!
//! # Namespaces
//! Each item in the graph is given its own namespace, which is further separated into
//! two distinct parts:
//! - Children of an item are direct descendents (i.e. their `parent` is a handle to the item)
//! - Imports of an item are indirect descendents created by `use` or `impl` directives. They are
//!   shadowed by Children with the same name.
//!
//! # Order of operations:
//! For order-of-operations information, see the [stage] module.
#![warn(clippy::all)]

pub(crate) mod format_utils;

pub mod table;

pub mod handle;

pub mod entry;

pub mod source;

pub mod type_kind;

pub mod type_expression;

pub mod stage {
    //! Type collection, evaluation, checking, and inference passes.
    //!
    //! # Order of operations
    //! 1. [mod@populate]: Populate the graph with nodes for every named item.
    //! 2. [mod@import]: Import the `use` nodes discovered in [Stage 1](populate).
    //! 3. [mod@categorize]: Categorize the nodes according to textual type information.
    //!    - Creates anonymous types (`fn(T) -> U`, `&T`, `[T]`, etc.) as necessary to fill in the
    //!      type graph
    //!    - Creates a new struct type for every enum struct-variant.
    //! 4. [mod@implement]: Import members of implementation modules into types.

    pub use populate::Populator;
    /// Stage 1: Populate the graph with nodes.
    pub mod populate;

    pub use import::import;
    /// Stage 2: Import the `use` nodes discovered in Stage 1.
    pub mod import;

    pub use categorize::categorize;
    /// Stage 3: Categorize the nodes according to textual type information.
    pub mod categorize;

    pub use implement::implement;
    /// Stage 4: Import members of `impl` blocks into their corresponding types.
    pub mod implement;

    // TODO: Make type inference stage 5
    // TODO: Use the type information stored in the [table]
    pub mod infer;
}