fastc 0.1.0

A safe C-like language that compiles to C11
Documentation 
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

//! Declaration AST nodes

use super::{Block, ConstExpr, Span, TypeExpr};

/// A top-level item
#[derive(Debug, Clone)]
pub enum Item {
    Fn(FnDecl),
    Struct(StructDecl),
    Enum(EnumDecl),
    Const(ConstDecl),
    Opaque(OpaqueDecl),
    Extern(ExternBlock),
    Use(UseDecl),
    Mod(ModDecl),
}

/// Function declaration
#[derive(Debug, Clone)]
pub struct FnDecl {
    pub is_unsafe: bool,
    pub name: String,
    pub params: Vec<Param>,
    pub return_type: TypeExpr,
    pub body: Block,
    pub span: Span,
}

/// Function parameter
#[derive(Debug, Clone)]
pub struct Param {
    pub name: String,
    pub ty: TypeExpr,
    pub span: Span,
}

/// Struct declaration
#[derive(Debug, Clone)]
pub struct StructDecl {
    pub repr: Option<Repr>,
    pub name: String,
    pub fields: Vec<Field>,
    pub span: Span,
}

/// Struct field
#[derive(Debug, Clone)]
pub struct Field {
    pub name: String,
    pub ty: TypeExpr,
    pub span: Span,
}

/// Enum declaration
#[derive(Debug, Clone)]
pub struct EnumDecl {
    pub repr: Option<Repr>,
    pub name: String,
    pub variants: Vec<Variant>,
    pub span: Span,
}

/// Enum variant
#[derive(Debug, Clone)]
pub struct Variant {
    pub name: String,
    pub fields: Option<Vec<TypeExpr>>,
    pub span: Span,
}

/// Constant declaration
#[derive(Debug, Clone)]
pub struct ConstDecl {
    pub name: String,
    pub ty: TypeExpr,
    pub value: ConstExpr,
    pub span: Span,
}

/// Opaque type declaration
#[derive(Debug, Clone)]
pub struct OpaqueDecl {
    pub name: String,
    pub span: Span,
}

/// Extern block
#[derive(Debug, Clone)]
pub struct ExternBlock {
    pub abi: String,
    pub items: Vec<ExternItem>,
    pub span: Span,
}

/// Items inside an extern block
#[derive(Debug, Clone)]
pub enum ExternItem {
    Fn(FnProto),
    Struct(StructDecl),
    Enum(EnumDecl),
    Opaque(OpaqueDecl),
}

/// Function prototype (no body)
#[derive(Debug, Clone)]
pub struct FnProto {
    pub is_unsafe: bool,
    pub name: String,
    pub params: Vec<Param>,
    pub return_type: TypeExpr,
    pub span: Span,
}

/// Representation attribute
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Repr {
    C,
    I8,
    U8,
    I16,
    U16,
    I32,
    U32,
    I64,
    U64,
}

/// Use declaration for importing items
#[derive(Debug, Clone)]
pub struct UseDecl {
    /// Module path (e.g., ["mylib", "utils"])
    pub path: Vec<String>,
    /// Items to import
    pub items: UseItems,
    /// Source span
    pub span: Span,
}

/// What items are being imported
#[derive(Debug, Clone)]
pub enum UseItems {
    /// Import a single item: `use mylib::Vector;`
    Single(String),
    /// Import multiple items: `use mylib::{Vector, Point};`
    Multiple(Vec<String>),
    /// Import all items: `use mylib::*;`
    Glob,
    /// Import the module itself: `use mylib;`
    Module,
}

/// Module declaration
#[derive(Debug, Clone)]
pub struct ModDecl {
    /// Visibility (true if public)
    pub is_pub: bool,
    /// Module name
    pub name: String,
    /// Inline module body, or None to load from file
    pub body: Option<Vec<Item>>,
    /// Source span
    pub span: Span,
}