Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Tests cannot be run #40

Open
cgmcintyr opened this issue Oct 20, 2019 · 1 comment
Open

Tests cannot be run #40

cgmcintyr opened this issue Oct 20, 2019 · 1 comment

Comments

@cgmcintyr
Copy link

cgmcintyr commented Oct 20, 2019 •
edited
Loading

Running cargo test from root directory results in the following error:

output 
warning: profiles for the non root package will be ignored, specify profiles at the workspace root:
package:   /home/cgm/devel/rust/enigma/enigma/Cargo.toml
workspace: /home/cgm/devel/rust/enigma/Cargo.toml
   Compiling quickcheck v0.9.0
   Compiling instruction-codegen v0.1.0 (/home/cgm/devel/rust/enigma/instruction-codegen)
error[E0433]: failed to resolve: use of undeclared type or module `trybuild`
 --> instruction-codegen/tests/progress.rs:3:13
  |
3 |     let t = trybuild::TestCases::new();
  |             ^^^^^^^^ use of undeclared type or module `trybuild`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0433`.
error: could not compile `instruction-codegen`.
warning: build failed, waiting for other jobs to finish...
error[E0432]: unresolved import `instruction`
  --> instruction-codegen/tests/01-parse-header.rs:23:5
   |
23 | use instruction::ins;
   |     ^^^^^^^^^^^ use of undeclared type or module `instruction`

error: cannot determine resolution for the macro `ins`
  --> instruction-codegen/tests/01-parse-header.rs:25:1
   |
25 | ins!(
   | ^^^
   |
   = note: import resolution is stuck, try simplifying macro imports

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0432`.
error: could not compile `instruction-codegen`.
warning: build failed, waiting for other jobs to finish...
error: build failed
@cgmcintyr
Copy link
Author

cgmcintyr commented Oct 20, 2019 •
edited
Loading

Running cargo test from the enigma directory also results in errors:

output 
warning: profiles for the non root package will be ignored, specify profiles at the workspace root:
package:   /home/cgm/devel/rust/enigma/enigma/Cargo.toml
workspace: /home/cgm/devel/rust/enigma/Cargo.toml
   Compiling enigma v0.1.0 (/home/cgm/devel/rust/enigma/enigma)
error[E0428]: the name `test` is defined multiple times
   --> enigma/src/bif/erf.rs:790:1
    |
35  | mod test {
    | -------- previous definition of the module `test` here
...
790 | mod test {
    | ^^^^^^^^ `test` redefined here
    |
    = note: `test` must be defined only once in the type namespace of this module

error[E0432]: unresolved import `crate::value::TryInto`
   --> enigma/src/bif/arith.rs:220:9
    |
220 |     use crate::value::TryInto;
    |         ^^^^^^^^^^^^^^^^^^^^^ no `TryInto` in `value`

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:796:9
    |
796 |         assert_almost_eq!(super::erf(-1.0), -0.84270079294971486934122063508260925929606699796630291, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:800:9
    |
800 |         assert_almost_eq!(super::erf(0.2), 0.22270258921047846617645303120925671669511570710081967, 1e-16);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:803:9
    |
803 |         assert_almost_eq!(super::erf(0.5), 0.5204998778130465376827466538919645287364515757579637, 1e-9);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:804:9
    |
804 |         assert_almost_eq!(super::erf(1.0), 0.84270079294971486934122063508260925929606699796630291, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:805:9
    |
805 |         assert_almost_eq!(super::erf(1.5), 0.96610514647531072706697626164594785868141047925763678, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:806:9
    |
806 |         assert_almost_eq!(super::erf(2.0), 0.99532226501895273416206925636725292861089179704006008, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:807:9
    |
807 |         assert_almost_eq!(super::erf(2.5), 0.99959304798255504106043578426002508727965132259628658, 1e-13);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:808:9
    |
808 |         assert_almost_eq!(super::erf(3.0), 0.99997790950300141455862722387041767962015229291260075, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:819:9
    |
819 |         assert_almost_eq!(super::erfc(-1.0), 1.8427007929497148693412206350826092592960669979663028, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:821:9
    |
821 |         assert_almost_eq!(super::erfc(0.1), 0.88753708398171510159528774898569593827660748149418343, 1e-15);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:824:9
    |
824 |         assert_almost_eq!(super::erfc(0.4), 0.57160764495333152354589037269227146256467072294018715, 1e-15);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:825:9
    |
825 |         assert_almost_eq!(super::erfc(0.5), 0.47950012218695346231725334610803547126354842424203654, 1e-9);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:826:9
    |
826 |         assert_almost_eq!(super::erfc(1.0), 0.15729920705028513065877936491739074070393300203369719, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:827:9
    |
827 |         assert_almost_eq!(super::erfc(1.5), 0.033894853524689272933023738354052141318589520742363247, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:828:9
    |
828 |         assert_almost_eq!(super::erfc(2.0), 0.0046777349810472658379307436327470713891082029599399245, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:829:9
    |
829 |         assert_almost_eq!(super::erfc(2.5), 0.00040695201744495893956421573997491272034867740371342016, 1e-13);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:830:9
    |
830 |         assert_almost_eq!(super::erfc(3.0), 0.00002209049699858544137277612958232037984770708739924966, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:831:9
    |
831 |         assert_almost_eq!(super::erfc(4.0), 0.000000015417257900280018852159673486884048572145253589191167, 1e-18);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:832:9
    |
832 |         assert_almost_eq!(super::erfc(5.0), 0.0000000000015374597944280348501883434853833788901180503147233804, 1e-22);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:833:9
    |
833 |         assert_almost_eq!(super::erfc(6.0), 2.1519736712498913116593350399187384630477514061688559e-17, 1e-26);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:834:9
    |
834 |         assert_almost_eq!(super::erfc(10.0), 2.0884875837625447570007862949577886115608181193211634e-45, 1e-55);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:835:9
    |
835 |         assert_almost_eq!(super::erfc(15.0), 7.2129941724512066665650665586929271099340909298253858e-100, 1e-109);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:836:9
    |
836 |         assert_almost_eq!(super::erfc(20.0), 5.3958656116079009289349991679053456040882726709236071e-176, 1e-186);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:849:9
    |
849 |         assert_almost_eq!(super::erf_inv(1e-15), 8.86226925452758013649e-16, 1e-30);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:851:9
    |
851 |         assert_almost_eq!(super::erf_inv(0.2), 0.1791434546212916764927, 1e-15);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:863:9
    |
863 |         assert_almost_eq!(super::erfc_inv(1e-100), 15.065574702593, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:864:9
    |
864 |         assert_almost_eq!(super::erfc_inv(1e-30), 8.1486162231699, 1e-12);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:865:9
    |
865 |         assert_almost_eq!(super::erfc_inv(1e-20), 6.6015806223551, 1e-13);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:866:9
    |
866 |         assert_almost_eq!(super::erfc_inv(1e-10), 4.5728249585449249378479309946884581365517663258840893, 1e-7);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:867:9
    |
867 |         assert_almost_eq!(super::erfc_inv(1e-5), 3.1234132743415708640270717579666062107939039971365252, 1e-11);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:868:9
    |
868 |         assert_almost_eq!(super::erfc_inv(0.1), 1.1630871536766741628440954340547000483801487126688552, 1e-14);
    |         ^^^^^^^^^^^^^^^^

error: cannot find macro `assert_almost_eq` in this scope
   --> enigma/src/bif/erf.rs:869:9
    |
869 |         assert_almost_eq!(super::erfc_inv(0.2), 0.90619380243682330953597079527631536107443494091638384, 1e-15);
    |         ^^^^^^^^^^^^^^^^

warning: unused macro definition
   --> enigma/src/exception.rs:208:1
    |
208 | / macro_rules! native_exception {
209 | |     ($x:expr) => {
210 | |         $x & Reason::EXF_NATIVE
211 | |     };
212 | | }
    | |_^
    |
    = note: `#[warn(unused_macros)]` on by default

warning: unused import: `BigInt`
  --> enigma/src/bif.rs:11:32
   |
11 | use crate::value::{self, Atom, BigInt, CastFrom, CastInto, Cons, Term, Tuple, Variant};
   |                                ^^^^^^
   |
   = note: `#[warn(unused_imports)]` on by default

warning: unused import: `CastInto`
 --> enigma/src/bif/binary.rs:6:36
  |
6 | use crate::value::{self, CastFrom, CastInto, Cons, Term, Tuple, Variant};
  |                                    ^^^^^^^^

warning: unused import: `Binary`
 --> enigma/src/bif/prim_buffer.rs:2:24
  |
2 | use crate::bitstring::{Binary, RcBinary};
  |                        ^^^^^^

warning: unused import: `crate::immix::Heap`
 --> enigma/src/bif/prim_buffer.rs:4:5
  |
4 | use crate::immix::Heap;
  |     ^^^^^^^^^^^^^^^^^^

warning: unused import: `Cons`
 --> enigma/src/bif/prim_buffer.rs:6:49
  |
6 | use crate::value::{self, CastFrom, CastFromMut, Cons, Term, Variant};
  |                                                 ^^^^

warning: unused import: `std::fs`
 --> enigma/src/bif/prim_buffer.rs:8:5
  |
8 | use std::fs;
  |     ^^^^^^^

warning: unused imports: `CastFrom`, `Tuple`, `Variant`, `self`
 --> enigma/src/bif/timer.rs:3:20
  |
3 | use crate::value::{self, CastFrom, Term, Tuple, Variant};
  |                    ^^^^  ^^^^^^^^        ^^^^^  ^^^^^^^

warning: unused import: `tokio::prelude::*`
 --> enigma/src/bif/timer.rs:7:5
  |
7 | use tokio::prelude::*;
  |     ^^^^^^^^^^^^^^^^^

warning: unused macro definition
   --> enigma/src/bitstring.rs:309:1
    |
309 | / macro_rules! native_endian {
310 | |     ($x:expr) => {
311 | |         if $x.contains(Flag::BSF_NATIVE) {
312 | |             $x.remove(Flag::BSF_NATIVE);
...   |
315 | |     };
316 | | }
    | |_^

warning: unused import: `self`
 --> enigma/src/etf.rs:1:19
  |
1 | use crate::atom::{self, Atom};
  |                   ^^^^

warning: unused import: `Cons`
 --> enigma/src/ets/bag.rs:3:30
  |
3 | use crate::value::{CastFrom, Cons, Term, Tuple};
  |                              ^^^^

warning: unused imports: `CastInto`, `Variant`
 --> enigma/src/ets/hash_table.rs:3:30
  |
3 | use crate::value::{CastFrom, CastInto, CastIntoMut, Cons, Term, Tuple, Variant};
  |                              ^^^^^^^^                                  ^^^^^^^

warning: unused import: `Cons`
 --> enigma/src/ets/ordered_set.rs:3:30
  |
3 | use crate::value::{CastFrom, Cons, Term, Tuple};
  |                              ^^^^

warning: unused import: `super::*`
    --> enigma/src/loader.rs:1323:9
     |
1323 |     use super::*;
     |         ^^^^^^^^

warning: unused import: `Index`
 --> enigma/src/port/renderer.rs:5:23
  |
5 | use std::ops::{Deref, Index, Range};
  |                       ^^^^^

warning: unused import: `Direction`
   --> enigma/src/port/renderer.rs:472:17
    |
472 |     use super::{Direction, LineBuffer, MAX_LINE};
    |                 ^^^^^^^^^

warning: unused import: `std::cell::RefCell`
   --> enigma/src/port/renderer.rs:474:9
    |
474 |     use std::cell::RefCell;
    |         ^^^^^^^^^^^^^^^^^^

warning: unused import: `std::rc::Rc`
   --> enigma/src/port/renderer.rs:475:9
    |
475 |     use std::rc::Rc;
    |         ^^^^^^^^^^^

warning: unnecessary parentheses around assigned value
   --> enigma/src/port.rs:304:20
    |
304 |     ios.c_lflag |= (libc::ISIG); // IEXTEN
    |                    ^^^^^^^^^^^^ help: remove these parentheses
    |
    = note: `#[warn(unused_parens)]` on by default

warning: unused import: `crate::instruction::Ptr`
 --> enigma/src/process.rs:6:5
  |
6 | use crate::instruction::Ptr;
  |     ^^^^^^^^^^^^^^^^^^^^^^^

warning: unused `#[macro_use]` import
  --> enigma/src/lib.rs:36:1
   |
36 | #[macro_use]
   | ^^^^^^^^^^^^

warning: use of deprecated item 'std::mem::uninitialized': use `mem::MaybeUninit` instead
   --> enigma/src/vm.rs:158:36
    |
158 |             process_pool: unsafe { std::mem::uninitialized() }, // I'm sorry, but we need a ref to vm in threadpool
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(deprecated)]` on by default

warning: use of deprecated item 'std::mem::uninitialized': use `mem::MaybeUninit` instead
   --> enigma/src/vm.rs:159:31
    |
159 |             runtime: unsafe { std::mem::uninitialized() }, // I'm sorry, but we need a ref to vm in threadpool
    |                               ^^^^^^^^^^^^^^^^^^^^^^^

warning: use of deprecated item 'std::mem::uninitialized': use `mem::MaybeUninit` instead
   --> enigma/src/process.rs:161:26
    |
161 |             bs: unsafe { std::mem::uninitialized() },
    |                          ^^^^^^^^^^^^^^^^^^^^^^^

warning: use of deprecated item 'std::mem::uninitialized': use `mem::MaybeUninit` instead
   --> enigma/src/servo_arc.rs:65:35
    |
65  |         let invalid: $container = ::std::mem::uninitialized();
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^
...
194 |         let ptr = (ptr as *const u8).offset(-offset_of!(ArcInner<T>, data));
    |                                              ----------------------------- in this macro invocation

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1502:36
     |
1502 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1565:36
     |
1565 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1588:36
     |
1588 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1602:36
     |
1602 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1618:36
     |
1618 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1635:36
     |
1635 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1652:36
     |
1652 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1667:34
     |
1667 |                 mfa: module::MFA(0, 0, 0),
     |                                  ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1667:37
     |
1667 |                 mfa: module::MFA(0, 0, 0),
     |                                     ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1675:36
     |
1675 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1688:36
     |
1688 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1700:41
     |
1700 |         let map = map!(heap, Term::atom(1) => Term::int(1));
     |                                         ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0308]: mismatched types
    --> enigma/src/bif.rs:1705:36
     |
1705 |         let args = vec![Term::atom(3)];
     |                                    ^ expected struct `atom::Atom`, found integer
     |
     = note: expected type `atom::Atom`
                found type `{integer}`

error[E0599]: no method named `cast_into` found for type `&value::Term` in the current scope
   --> enigma/src/bif/arith.rs:226:57
    |
226 |         while let Ok(value::Cons { head, tail }) = cons.cast_into() {
    |                                                         ^^^^^^^^^ method not found in `&value::Term`
    |
    = help: items from traits can only be used if the trait is in scope
    = note: the following trait is implemented but not in scope; perhaps add a `use` for it:
            `use crate::value::CastInto;`

error[E0614]: type `value::Term` cannot be dereferenced
   --> enigma/src/bif/arith.rs:227:22
    |
227 |             vec.push(*head);
    |                      ^^^^^

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:156:31
    |
156 |         let elem = Term::atom(1);
    |                               ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:157:51
    |
157 |         let list = from_vec(heap, vec![Term::atom(3), Term::atom(2)]);
    |                                                   ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:157:66
    |
157 |         let list = from_vec(heap, vec![Term::atom(3), Term::atom(2)]);
    |                                                                  ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:161:31
    |
161 |         let elem = Term::atom(1);
    |                               ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:162:51
    |
162 |         let list = from_vec(heap, vec![Term::atom(3), Term::atom(2), Term::atom(1)]);
    |                                                   ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:162:66
    |
162 |         let list = from_vec(heap, vec![Term::atom(3), Term::atom(2), Term::atom(1)]);
    |                                                                  ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:162:81
    |
162 |         let list = from_vec(heap, vec![Term::atom(3), Term::atom(2), Term::atom(1)]);
    |                                                                                 ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:174:31
    |
174 |         let elem = Term::atom(1);
    |                               ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:180:31
    |
180 |         let elem = Term::atom(3);
    |                               ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:182:45
    |
182 |         let target = tup2!(heap, Term::atom(3), Term::int(2));
    |                                             ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:186:40
    |
186 |                 tup2!(heap, Term::atom(1), Term::int(4)),
    |                                        ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:187:40
    |
187 |                 tup2!(heap, Term::atom(2), Term::int(3)),
    |                                        ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/lists.rs:189:40
    |
189 |                 tup2!(heap, Term::atom(4), Term::int(1)),
    |                                        ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/pdict.rs:102:36
    |
102 |         let args = vec![Term::atom(1), Term::int(2)];
    |                                    ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/pdict.rs:106:36
    |
106 |         let args = vec![Term::atom(1), Term::int(3)];
    |                                    ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/pdict.rs:110:36
    |
110 |         let args = vec![Term::atom(2), Term::int(1)];
    |                                    ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

error[E0308]: mismatched types
   --> enigma/src/bif/pdict.rs:114:36
    |
114 |         let args = vec![Term::atom(2)];
    |                                    ^ expected struct `atom::Atom`, found integer
    |
    = note: expected type `atom::Atom`
               found type `{integer}`

warning: unused import: `futures::prelude`
  --> enigma/src/instruction.rs:13:5
   |
13 | use futures::prelude::*;
   |     ^^^^^^^^^^^^^^^^

warning: unused import: `tokio::prelude`
  --> enigma/src/process.rs:23:5
   |
23 | use tokio::prelude::*;
   |     ^^^^^^^^^^^^^^

warning: unused import: `futures::prelude`
  --> enigma/src/process.rs:25:5
   |
25 | use futures::prelude::*;
   |     ^^^^^^^^^^^^^^^^

error: aborting due to 66 previous errors

Some errors have detailed explanations: E0308, E0428, E0432, E0599, E0614.
For more information about an error, try `rustc --explain E0308`.
error: could not compile `enigma`.

To learn more, run the command again with --verbose.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@cgmcintyr