scala 0.1.0

A experimental Scala interpreter written in Rust: lexer, parser, type inference, and tree-walking evaluation with a REPL.
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

use std::env;
use std::fs;
use std::process;

fn print_usage() {
    println!("scala - A Scala interpreter written in Rust");
    println!();
    println!("Usage:");
    println!("  scala <file.scala>           Run a Scala source file");
    println!("  scala --repl                 Start interactive REPL");
    println!("  scala --check <file>         Type-check only");
    println!("  scala --tokens <file>        Dump tokens");
    println!("  scala --ast <file>           Dump AST");
    println!("  scala --help                 Show this help");
    println!("  scala --version              Show this version");
}

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() == 1 {
        println!("scala: no input files");
        println!("Use --repl for interactive mode or <file.scala> to run a file.");
        process::exit(1);
    }

    match args[1].as_str() {
        "--help" | "-h" => {
            print_usage();
        }
        "--version" | "-v" => {
            println!("scala 0.1.0");
        }
        "--repl" => {
            scala::repl::run_repl();
        }
        "--check" => {
            if args.len() < 3 {
                eprintln!("error: --check requires a file argument");
                process::exit(1);
            }
            let path = &args[2];
            let source = fs::read_to_string(path)
                .unwrap_or_else(|e| {
                    eprintln!("error: cannot read '{}': {}", path, e);
                    process::exit(1);
                });
            if let Err(e) = scala::run_file(&source, true, false, false) {
                eprintln!("{}", e);
                process::exit(1);
            }
        }
        "--tokens" => {
            if args.len() < 3 {
                eprintln!("error: --tokens requires a file argument");
                process::exit(1);
            }
            let path = &args[2];
            let source = fs::read_to_string(path)
                .unwrap_or_else(|e| {
                    eprintln!("error: cannot read '{}': {}", path, e);
                    process::exit(1);
                });
            if let Err(e) = scala::run_file(&source, false, true, false) {
                eprintln!("{}", e);
                process::exit(1);
            }
        }
        "--ast" => {
            if args.len() < 3 {
                eprintln!("error: --ast requires a file argument");
                process::exit(1);
            }
            let path = &args[2];
            let source = fs::read_to_string(path)
                .unwrap_or_else(|e| {
                    eprintln!("error: cannot read '{}': {}", path, e);
                    process::exit(1);
                });
            if let Err(e) = scala::run_file(&source, false, false, true) {
                eprintln!("{}", e);
                process::exit(1);
            }
        }
        arg if arg.starts_with('-') => {
            eprintln!("error: unknown option '{}'", arg);
            eprintln!("Use --help for usage information.");
            process::exit(1);
        }
        file => {
            let source = fs::read_to_string(file)
                .unwrap_or_else(|e| {
                    eprintln!("error: cannot read '{}': {}", file, e);
                    process::exit(1);
                });
            if let Err(e) = scala::run_file(&source, false, false, false) {
                eprintln!("{}", e);
                process::exit(1);
            }
        }
    }
}