Add complex basic type

Author: windelbouwman

Cargo.lock

@@ -300,4 +300,5 @@ pub enum Comparison {
 pub enum Number {
     Integer { value: i32 },
     Float { value: f64 },
+    Complex { real: f64, imag: f64 },
 }

parser/src/ast.rs

@@ -3,6 +3,7 @@
 pub enum Tok {
     Name { name: String },
     Number { value: String },
+    Complex { real: f64, imag: f64 },
     String { value: String },
     Bytes { value: Vec<u8> },
     Newline,

parser/src/token.rs

@@ -37,3 +37,7 @@
     pass
 
 assert int() == 0
+
+a = complex(2, 4)
+assert type(a) is complex
+assert type(a + a) is complex

tests/snippets/basic_types.py

@@ -5,6 +5,7 @@ authors = ["Shing Lyu <[email protected]>"]
 
 [dependencies]
 bitflags = "1.0.4"
+num-complex = "0.2"
 log = "0.3"
 rustpython_parser = {path = "../parser"}
 serde = "1.0.66"

vm/Cargo.toml

@@ -126,7 +126,6 @@ fn builtin_compile(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     compile::compile(vm, &source, mode, None)
 }
 
-// builtin_complex
 // builtin_delattr
 
 fn builtin_dir(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -543,6 +542,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("bytes"), ctx.bytes_type());
     dict.insert(String::from("chr"), ctx.new_rustfunc(builtin_chr));
     dict.insert(String::from("compile"), ctx.new_rustfunc(builtin_compile));
+    dict.insert(String::from("complex"), ctx.complex_type());
     dict.insert(String::from("dict"), ctx.dict_type());
     dict.insert(String::from("divmod"), ctx.new_rustfunc(builtin_divmod));
     dict.insert(String::from("dir"), ctx.new_rustfunc(builtin_dir));

vm/src/builtins.rs

@@ -10,9 +10,9 @@ let call_function = 0x64;
 /*
  * Primitive instruction type, which can be encoded and decoded.
  */
-extern crate rustpython_parser;
 
-use self::rustpython_parser::ast;
+use num_complex::Complex64;
+use rustpython_parser::ast;
 use std::collections::HashMap;
 use std::fmt;
 
@@ -197,6 +197,7 @@ pub enum CallType {
 pub enum Constant {
     Integer { value: i32 }, // TODO: replace by arbitrary big int math.
     Float { value: f64 },
+    Complex { value: Complex64 },
     Boolean { value: bool },
     String { value: String },
     Bytes { value: Vec<u8> },

vm/src/bytecode.rs

@@ -6,12 +6,11 @@
  *   https://github.com/micropython/micropython/blob/master/py/compile.c
  */
 
-extern crate rustpython_parser;
-
-use self::rustpython_parser::{ast, parser};
 use super::bytecode::{self, CallType, CodeObject, Instruction};
 use super::pyobject::{PyObject, PyObjectKind, PyResult};
 use super::vm::VirtualMachine;
+use num_complex::Complex64;
+use rustpython_parser::{ast, parser};
 
 struct Compiler {
     code_object_stack: Vec<CodeObject>,
@@ -846,6 +845,9 @@ impl Compiler {
                 let const_value = match value {
                     ast::Number::Integer { value } => bytecode::Constant::Integer { value: *value },
                     ast::Number::Float { value } => bytecode::Constant::Float { value: *value },
+                    ast::Number::Complex { real, imag } => bytecode::Constant::Complex {
+                        value: Complex64::new(*real, *imag),
+                    },
                 };
                 self.emit(Instruction::LoadConst { value: const_value });
             }
@@ -1301,8 +1303,8 @@ mod tests {
     use super::bytecode::CodeObject;
     use super::bytecode::Constant::*;
     use super::bytecode::Instruction::*;
-    use super::rustpython_parser::parser;
     use super::Compiler;
+    use rustpython_parser::parser;
     fn compile_exec(source: &str) -> CodeObject {
         let mut compiler = Compiler::new();
         compiler.push_new_code_object(Option::None, "<module>".to_string());

vm/src/compile.rs

@@ -1074,6 +1074,7 @@ impl Frame {
         match *value {
             bytecode::Constant::Integer { ref value } => vm.ctx.new_int(*value),
             bytecode::Constant::Float { ref value } => vm.ctx.new_float(*value),
+            bytecode::Constant::Complex { ref value } => vm.ctx.new_complex(*value),
             bytecode::Constant::String { ref value } => vm.new_str(value.clone()),
             bytecode::Constant::Bytes { ref value } => vm.ctx.new_bytes(value.clone()),
             bytecode::Constant::Boolean { ref value } => vm.new_bool(value.clone()),

vm/src/frame.rs

@@ -3,9 +3,12 @@ extern crate bitflags;
 #[macro_use]
 extern crate log;
 // extern crate env_logger;
+extern crate num_complex;
 extern crate serde;
 extern crate serde_json;
 
+extern crate rustpython_parser;
+
 //extern crate eval; use eval::eval::*;
 // use py_code_object::{Function, NativeType, PyCodeObject};