Dino compiler: language, formatter, language server, docs, editor support

Compiler in Rust (lexer, parser, checker, C codegen), maps, chars,
dino fmt, dino lsp (diagnostics, formatting, outline, definition,
hover, completion, signature help), docs, examples, VS Code/Vim files.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Your NameandClaude Sonnet 5.5 committed 2026-11-07 23:46:12 +01:00
1 parent 3e2779f447
commit eaf9567a36
117 files changed
+19970

No files matched your search

+15
View File
@@ -0,0 +1,15 @@
// The shape of a parsed calculation.
pub enum Node {
Num(value: float)
Var(name: string)
Neg(inner: []Node)
Bin(op: string, sides: []Node)
Call(name: string, args: []Node)
Assign(name: string, value: []Node)
}
// Enums can't hold themselves directly, so children live in a list of one or two.
pub func neg(n: Node): Node { return Node.Neg([n]) }
pub func bin(op: string, l, r: Node): Node { return Node.Bin(op, [l, r]) }
pub func assign(name: string, v: Node): Node { return Node.Assign(name, [v]) }
+83
View File
@@ -0,0 +1,83 @@
// Evaluates a parsed calculation. Variables and functions live in `Scope`.
import ast
import math
pub struct Builtin {
pub name: string
pub arity: int
pub run: func([]float): float
}
pub struct Scope {
variables: map[string, float]
builtins: map[string, Builtin]
pub func set(name: string, v: float) {
variables[name] = v
}
pub func eval(n: ast.Node): (float, error) {
match n {
Num(v) => return v, nil
Var(name) => {
var v = variables.get(name)
if v == nil { return 0.0, error("unknown variable `{name}`") }
return v, nil
}
Neg(inner) => {
var x = eval(inner[0])?
return -x, nil
}
Assign(name, value) => {
var x = eval(value[0])?
set(name, x)
return x, nil
}
Bin(op, sides) => {
var a = eval(sides[0])?
var b = eval(sides[1])?
return apply(op, a, b)
}
Call(name, args) => {
if !builtins.has(name) { return 0.0, error("unknown function `{name}`") }
var b = builtins[name]
if args.len() != b.arity {
return 0.0, error("`{name}` takes {b.arity} argument(s), but {args.len()} given")
}
var vals: []float
for a in args { vals.push(eval(a)?) }
return b.run(vals), nil
}
}
}
func apply(op: string, a, b: float): (float, error) {
match op {
"+" => return a + b, nil
"-" => return a - b, nil
"*" => return a * b, nil
"/" => {
if b == 0.0 { return 0.0, error("division by zero") }
return a / b, nil
}
"%" => {
if b == 0.0 { return 0.0, error("division by zero") }
return a - b * math.floor(a / b), nil
}
"^" => return math.pow(a, b), nil
_ => return 0.0, error("unknown operator `{op}`")
}
}
}
pub func new_scope(): Scope {
var s = Scope{}
s.builtins["sqrt"] = Builtin{"sqrt", 1, a => math.sqrt(a[0])}
s.builtins["abs"] = Builtin{"abs", 1, a => math.abs(a[0])}
s.builtins["max"] = Builtin{"max", 2, a => math.max(a[0], a[1])}
s.builtins["min"] = Builtin{"min", 2, a => math.min(a[0], a[1])}
s.builtins["sum"] = Builtin{"sum", 3, a => a[0] + a[1] + a[2]}
s.set("pi", math.PI)
s.set("e", math.E)
return s
}
+43
View File
@@ -0,0 +1,43 @@
import parser
import eval
import os
// Evaluates one line and prints the answer or the problem.
func run_line(scope: shared eval.Scope, line: string) {
var text = line.trim()
if text == "" { return }
var tree, err = parser.parse(text)
if err != nil {
print(" error:", err)
return
}
var value, err2 = scope.eval(tree)
if err2 != nil {
print(" error:", err2)
return
}
print(" =", value)
}
// Reads lines from the file named on the command line, or from the keyboard.
func main() {
var scope = shared eval.new_scope()
var args = os.args
if args.len() > 1 {
var text, err = os.read_file(args[1])
if err != nil {
print("cannot read", args[1], err)
os.exit(1)
}
for line in text.lines() {
print(line)
run_line(scope, line)
}
return
}
for {
var line = os.read_line()
if line == nil { break }
run_line(scope, line)
}
}
+130
View File
@@ -0,0 +1,130 @@
// Recursive descent: assignment < + - < * / % < unary minus < ^ < calls and atoms.
import token
import ast
pub struct Parser {
tokens: []token.Token
at: int
func peek(): token.Token { return tokens[at] }
func next(): token.Token {
var t = tokens[at]
if at < tokens.len() - 1 { at += 1 }
return t
}
func is_op(text: string): bool {
var t = peek()
return t.kind == token.Kind.Op && t.text == text
}
func expect(kind: token.Kind, what: string): error {
if peek().kind != kind {
return error("expected {what} at column {peek().pos + 1}")
}
next()
return nil
}
pub func statement(): (ast.Node, error) {
// `name = expression`
if peek().kind == token.Kind.Name && at + 1 < tokens.len() {
var after = tokens[at + 1]
if after.kind == token.Kind.Op && after.text == "=" {
var name = next().text
next()
var value = sum()?
return ast.assign(name, value), finish()
}
}
var e = sum()?
return e, finish()
}
func finish(): error {
if peek().kind != token.Kind.End {
return error("unexpected `{peek().text}` at column {peek().pos + 1}")
}
return nil
}
func sum(): (ast.Node, error) {
var left = product()?
for is_op("+") || is_op("-") {
var op = next().text
var right = product()?
left = ast.bin(op, left, right)
}
return left, nil
}
func product(): (ast.Node, error) {
var left = unary()?
for is_op("*") || is_op("/") || is_op("%") {
var op = next().text
var right = unary()?
left = ast.bin(op, left, right)
}
return left, nil
}
func unary(): (ast.Node, error) {
if is_op("-") {
next()
var inner = unary()?
return ast.neg(inner), nil
}
return power()
}
func power(): (ast.Node, error) {
var base = atom()?
if is_op("^") {
next()
var exp = unary()?
return ast.bin("^", base, exp), nil
}
return base, nil
}
func atom(): (ast.Node, error) {
var t = next()
match t.kind {
Num => {
var v, err = t.text.to_float()
if err != nil { return ast.Node.Num(0.0), error("bad number `{t.text}` at column {t.pos + 1}") }
return ast.Node.Num(v), nil
}
Name => {
if peek().kind == token.Kind.Open {
next()
var args: []ast.Node
if peek().kind != token.Kind.Close {
args.push(sum()?)
for is_op(",") {
next()
args.push(sum()?)
}
}
expect(token.Kind.Close, "`)`")?
return ast.Node.Call(t.text, args), nil
}
return ast.Node.Var(t.text), nil
}
Open => {
var inner = sum()?
expect(token.Kind.Close, "`)`")?
return inner, nil
}
End => return ast.Node.Num(0.0), error("the calculation ends too early (column {t.pos + 1})")
_ => return ast.Node.Num(0.0), error("unexpected `{t.text}` at column {t.pos + 1}")
}
}
}
pub func parse(src: string): (ast.Node, error) {
var tokens = token.tokenize(src)?
var p = Parser{tokens, 0}
return p.statement()
}
+30
View File
@@ -0,0 +1,30 @@
1 + 2 * 3
= 7.0
(1 + 2) * 3
= 9.0
-2 ^ 2
= -4.0
2 ^ 3 ^ 2
= 512.0
x = 10 / 4
= 2.5
x * 2 + pi
= 8.14159265358979
sqrt(16) + abs(-3)
= 7.0
max(2, 7) % 4
= 3.0
y
error: unknown variable `y`
1 / 0
error: division by zero
foo(1)
error: unknown function `foo`
sqrt(1, 2)
error: `sqrt` takes 1 argument(s), but 2 given
3 +
error: the calculation ends too early (column 4)
4 $ 4
error: unexpected `$` at column 3
sum(1, 2, 3) * x
= 15.0
+15
View File
@@ -0,0 +1,15 @@
1 + 2 * 3
(1 + 2) * 3
-2 ^ 2
2 ^ 3 ^ 2
x = 10 / 4
x * 2 + pi
sqrt(16) + abs(-3)
max(2, 7) % 4
y
1 / 0
foo(1)
sqrt(1, 2)
3 +
4 $ 4
sum(1, 2, 3) * x
+49
View File
@@ -0,0 +1,49 @@
// Turns the text of a calculation into a list of tokens.
pub enum Kind {
Num
Name
Op
Open
Close
End
}
pub struct Token {
pub kind: Kind
pub text: string
pub pos: int
}
pub func tokenize(src: string): ([]Token, error) {
var tokens: []Token
var i = 0
for i < src.len() {
var c = src[i]
if c == ' ' {
i += 1
continue
}
var start = i
if c.is_digit() || c == '.' {
for i < src.len() && (src[i].is_digit() || src[i] == '.') { i += 1 }
tokens.push(Token{Kind.Num, src[start..i], start})
} else if c.is_letter() || c == '_' {
for i < src.len() && (src[i].is_alnum() || src[i] == '_') { i += 1 }
tokens.push(Token{Kind.Name, src[start..i], start})
} else if "+-*/^%=,".contains(string(c)) {
tokens.push(Token{Kind.Op, string(c), start})
i += 1
} else if c == '(' {
tokens.push(Token{Kind.Open, "(", start})
i += 1
} else if c == ')' {
tokens.push(Token{Kind.Close, ")", start})
i += 1
} else {
return tokens, error("unexpected `{c}` at column {i + 1}")
}
}
tokens.push(Token{Kind.End, "", src.len()})
return tokens, nil
}