[WIP] Add a proper REPL #464

Stupremee · 2020-06-02T21:31:08Z

This PR will introduce a proper Repl using rustyline and the jit backend.
My current plan is to have a buffer which holds the code.
Every line will be processed like this:

append code to code buffer
check semantics of buffer
if new code contains main method, execute it and reset the buffer
otherwise just add the code to the buffer

It's probably possible to not reset the buffer and just override the main method in the existing program.
I'n also thinking about making the buffer not a string, but a list of parsed statements.

Resolves #372

src/lib.rs

Cargo.toml

jyn514 · 2020-06-03T00:29:57Z

src/repl/helper.rs

+    fn complete(
+        &self,
+        _line: &str,
+        _pos: usize,
+        _ctx: &Context<'_>,
+    ) -> Result<(usize, Vec<Pair>), ReadlineError> {
+        Ok((0, vec![]))
+    }


I'd love to do lots of fancy things with tab-completion, but that's a larger project, no need for it in a first draft.

src/repl/helper.rs

src/repl/mod.rs

jyn514 · 2020-06-03T00:39:29Z

if new code contains main method, execute it and reset the buffer, otherwise just add the code to the buffer

I'd actually like to evaluate things as expressions by default, not as declarations. This is how node behaves:

> 1 + 2
3

and also GHCI and python

Prelude> 1 + 2
3
>>> 1 + 2
3

You can parse things as expressions by creating a new Analyzer and calling .expr(). This would be easiest by using the analyze function in src/analyze/mod.rs - it's currently test-only, but I think it's fine to make it usable in all contexts.

Stupremee · 2020-06-06T21:32:20Z

But how should the result of the expression then be calculated? We do not have an interpreter, only a jit and I have no idea how we can get the result of the jitted code that gets executed.

- Hide repl behind a feature gate - Create basic command module - Start repl automatically if no input is provided

- Move all methods from swcc module to a common module - Add swcci binary

jyn514 · 2020-06-08T21:57:22Z

src/bin/common/mod.rs

+pub(super) const USAGE: &str = "\
 usage: swcc [--help | -h] [--version | -V] [--debug-ir] [--debug-ast] [--debug-lex]
           [--debug-hir] [--jit] [--no-link | -c] [--preprocess-only | -E]
           [-I <dir>] [-D <id[=val]>] [<file>]";


I don't think it makes sense to share this across both binaries.

Yes I realized that after I committed it 😅
It will be fixed asap.

- backtrace mod and ColorChoice are now in common mod - Add some first code checking stuff to repl execute_code

- entered expression is inserted in the return expression of the main function - result of the "program" is printed to stdout

jyn514 · 2020-06-14T18:05:24Z

src/analyze/mod.rs

@@ -1052,6 +1052,7 @@ impl PureAnalyzer {
    /// This returns an opaque index to the `Metadata`.
    fn declare(&mut self, mut decl: Variable, init: bool, location: Location) -> Symbol {
        if decl.id == "main".into() {
+            println!("main: {:?}", decl);


Suggested change

println!("main: {:?}", decl);

jyn514 · 2020-06-14T18:06:19Z

src/bin/repl/mod.rs

+        let expr = match analyze(code, Parser::expr, PureAnalyzer::expr) {
+            Ok(mut expr) => {
+                expr.ctype = types::Type::Int(true);
+                expr
+            }
+            Err(err) => {
+                println!("error: {}", err.data);
+                return;
+            }
+        };
+        let function_type = types::FunctionType {
+            return_type: Box::new(types::Type::Int(true)),
+            params: vec![],
+            varargs: false,
+        };
+        let qualifiers = hir::Qualifiers {
+            volatile: false,
+            c_const: false,
+            func: hir::FunctionQualifiers {
+                inline: false,
+                no_return: false,
+            },
+        };
+
+        let main = hir::Variable {
+            ctype: types::Type::Function(function_type),
+            storage_class: data::StorageClass::Extern,
+            qualifiers,
+            id: saltwater::InternedStr::get_or_intern("main"),
+        };
+
+        let span = expr.location;
+        let stmt = span.with(hir::StmtType::Return(Some(expr)));
+        let init = hir::Initializer::FunctionBody(vec![stmt]);
+        let decl = hir::Declaration {
+            symbol: main.insert(),
+            init: Some(init),
+        };
+        let (result, _warns) = ir::compile(module, vec![span.with(decl)], false);


This looks useful on its own, can you make it a function in src/lib.rs called eval() that's implemented on JIT?

jyn514 · 2020-06-14T18:07:58Z

src/bin/repl/mod.rs

+            ctype: types::Type::Function(function_type),
+            storage_class: data::StorageClass::Extern,
+            qualifiers,
+            id: saltwater::InternedStr::get_or_intern("main"),


Suggested change

id: saltwater::InternedStr::get_or_intern("main"),

id: "main".into(),

jyn514 · 2020-06-14T18:08:22Z

src/bin/repl/mod.rs

+        let qualifiers = hir::Qualifiers {
+            volatile: false,
+            c_const: false,
+            func: hir::FunctionQualifiers {
+                inline: false,
+                no_return: false,
+            },
+        };


Suggested change

let qualifiers = hir::Qualifiers {

volatile: false,

c_const: false,

func: hir::FunctionQualifiers {

inline: false,

no_return: false,

},

};

let qualifiers = hir::Qualifiers::default();

jyn514 · 2020-06-14T18:11:52Z

src/bin/repl/mod.rs

+        let module = initialize_jit_module();
+        let expr = match analyze(code, Parser::expr, PureAnalyzer::expr) {
+            Ok(mut expr) => {
+                expr.ctype = types::Type::Int(true);


This doesn't look right. What's this meant to do?

Yeah, this crashes on strings:

>> "a" The application panicked (crashed). Message: verification error: - inst1 (return v0): arg 0 (v0) has type i64, must match function signature of i32 note: while compiling function u0:0() -> i32 system_v { gv0 = symbol colocated u1:0 block0: v0 = global_value.i64 gv0 return v0 }

Instead you could use a function name other than main and set the return type to the type of the expression. Then you decide how to display the result depending on the type. That would also fix the current bug where 'a' is displayed as 99.

That's a good idea

I had this code there, because otherwise I got an error from cranelift that it expected an i32 but got i64.

verification error: - inst1 (return v0): arg 0 (v0) has type i64, must match function signature of i32 note: while compiling function u0:0() -> i32 system_v { block0: v0 = iconst.i64 1 return v0 }

jyn514 · 2020-06-14T18:20:32Z

src/bin/repl/mod.rs

+        if let Err(err) = result {
+            println!("failed to compile: {}", err.data);
+            return;
+        }
+
+        let module = result.unwrap();


Try to avoid unwrap if possible.

Suggested change

if let Err(err) = result {

println!("failed to compile: {}", err.data);

return;

}

let module = result.unwrap();

let module = match result {

Err(err) => {

println!("failed to compile: {}", err.data);

return;

}

Ok(module) => module),

};

Stupremee · 2020-07-24T20:27:35Z

I will close this pull request and reopen one because I have lost the overview and am not really satisfied with this one.

jyn514 reviewed Jun 3, 2020

View reviewed changes

Add repl module with basic skeleton code

89dc56e

Stupremee added 5 commits June 6, 2020 23:53

Improve Repl

c16d59b

- Hide repl behind a feature gate - Create basic command module - Start repl automatically if no input is provided

Make analyze function public and add type command

3b00ec7

Use global array and implement command hinting

c2ef7e7

Command hinting only show rest of command

83668a2

Move main to bin module

fd7696c

- Move all methods from swcc module to a common module - Add swcci binary

jyn514 reviewed Jun 8, 2020

View reviewed changes

Stupremee added 2 commits June 14, 2020 18:12

Move most of common module in swcc bin...

cba41e5

- backtrace mod and ColorChoice are now in common mod - Add some first code checking stuff to repl execute_code

Repl works now

0ea9c91

- entered expression is inserted in the return expression of the main function - result of the "program" is printed to stdout

jyn514 reviewed Jun 14, 2020

View reviewed changes

Stupremee closed this Jul 24, 2020

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[WIP] Add a proper REPL #464

[WIP] Add a proper REPL #464

Stupremee commented Jun 2, 2020 •

edited

Loading

jyn514 Jun 3, 2020

jyn514 commented Jun 3, 2020

Stupremee commented Jun 6, 2020

jyn514 Jun 8, 2020

Stupremee Jun 8, 2020

jyn514 Jun 14, 2020

Stupremee Jun 14, 2020

jyn514 Jun 14, 2020

jyn514 Jun 14, 2020

jyn514 Jun 14, 2020

jyn514 Jun 14, 2020

jyn514 Jun 14, 2020

jyn514 Jun 14, 2020

Stupremee Jun 14, 2020

Stupremee Jun 14, 2020 •

edited

Loading

jyn514 Jun 14, 2020

Stupremee commented Jul 24, 2020

	id: saltwater::InternedStr::get_or_intern("main"),
	id: "main".into(),

[WIP] Add a proper REPL #464

[WIP] Add a proper REPL #464

Conversation

Stupremee commented Jun 2, 2020 • edited Loading

Choose a reason for hiding this comment

jyn514 commented Jun 3, 2020

Stupremee commented Jun 6, 2020

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Stupremee Jun 14, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Stupremee commented Jul 24, 2020

Stupremee commented Jun 2, 2020 •

edited

Loading

Stupremee Jun 14, 2020 •

edited

Loading