[INFO] crate rasen-dsl 0.2.0 is already in cache
[INFO] checking rasen-dsl-0.2.0 against master#fdc0011561c6365c596dfd8fa1ef388162bc89c7 for pr-66504-1
[INFO] extracting crate rasen-dsl 0.2.0 into /workspace/builds/worker-7/source
[INFO] validating manifest of crates.io crate rasen-dsl 0.2.0 on toolchain fdc0011561c6365c596dfd8fa1ef388162bc89c7
[INFO] running `"/workspace/cargo-home/bin/cargo" "+fdc0011561c6365c596dfd8fa1ef388162bc89c7" "read-manifest" "--manifest-path" "Cargo.toml"`
[INFO] started tweaking crates.io crate rasen-dsl 0.2.0
[INFO] finished tweaking crates.io crate rasen-dsl 0.2.0
[INFO] tweaked toml for crates.io crate rasen-dsl 0.2.0 written to /workspace/builds/worker-7/source/Cargo.toml
[INFO] running `"/workspace/cargo-home/bin/cargo" "+fdc0011561c6365c596dfd8fa1ef388162bc89c7" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"`
[INFO] running `"/workspace/cargo-home/bin/cargo" "+fdc0011561c6365c596dfd8fa1ef388162bc89c7" "fetch" "--locked" "--manifest-path" "Cargo.toml"`
[INFO] running `"docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "MAP_USER_ID=0" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--network" "none" "rustops/crates-build-env" "/opt/rustwide/cargo-home/bin/cargo" "+fdc0011561c6365c596dfd8fa1ef388162bc89c7" "check" "--frozen" "--all" "--all-targets"`
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] [stdout] bfb162ecf67e534ac0ffe26f8f35e85a7464de9b7e1a7d5e5e35e5ddf08dbd61
[INFO] running `"docker" "start" "-a" "bfb162ecf67e534ac0ffe26f8f35e85a7464de9b7e1a7d5e5e35e5ddf08dbd61"`
[INFO] [stderr]    Compiling rasen v0.12.0
[INFO] [stderr]    Compiling derive_more v0.7.1
[INFO] [stderr]    Compiling rasen-dsl v0.2.0 (/opt/rustwide/workdir)
[INFO] [stderr]    Compiling num-derive v0.1.44
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> codegen/functions.rs:15:20
[INFO] [stderr]    |
[INFO] [stderr] 15 |             TRAITS.into_iter()
[INFO] [stderr]    |                    ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(array_into_iter)]` on by default
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]    --> codegen/math.rs:118:30
[INFO] [stderr]     |
[INFO] [stderr] 118 |                     MATH_OPS.into_iter()
[INFO] [stderr]     |                              ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr]     Checking spirv_headers v1.3.4
[INFO] [stderr]     Checking rspirv v0.5.4
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:10:402
[INFO] [stderr]    |
[INFO] [stderr] 10 | # [ derive ( Copy , Clone , Debug ) ] pub struct Mat2 ( pub [ f32 ; 4usize ] ) ; impl Matrix < Vec2 , Float > for Mat2 { fn identity ( ) -> Self { Mat2 ( [ 1.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 2u32 } } impl ValueIter < Float > for Mat2 { type Iter = :: std :: vec :: IntoIter < Value < Float >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < Mat2 >> for [ f32 ; 4usize ] { fn into ( self ) -> Value < Mat2 > { Value :: Concrete ( Mat2 ( self ) ) } } impl Into < Value < Mat2 >> for Mat2 { fn into ( self ) -> Value < Mat2 > { Value :: Concrete ( self ) } } impl Index < u32 > for Mat2 { type Output = f32 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for Mat2 { type Output = Mat2 ; fn into_value ( self ) -> Value < Mat2 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: Mat2 ( self . 0 ) ) ) } } # [ inline ] pub fn mat2 < T0 , T1 > ( t0 : T0 , t1 : T1 ) -> Value < Mat2 > where T0 : IntoValue < Output = Vec2 > , T1 : IntoValue < Output = Vec2 > { let ( module , function , t0 , t1 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , ) => { return { Value :: Concrete ( Mat2 ( [ t0 . 0 , t0 . 1 , t1 . 0 , t1 . 1 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: MAT2 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < Mat2 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < Mat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: MAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < Mat2 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < Mat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: MAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < Mat2 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < Mat2 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: MAT2 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < Mat2 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < Mat2 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: MAT2 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                  ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(array_into_iter)]` on by default
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:12:410
[INFO] [stderr]    |
[INFO] [stderr] 12 | # [ derive ( Copy , Clone , Debug ) ] pub struct DMat2 ( pub [ f64 ; 4usize ] ) ; impl Matrix < DVec2 , Double > for DMat2 { fn identity ( ) -> Self { DMat2 ( [ 1.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 2u32 } } impl ValueIter < Double > for DMat2 { type Iter = :: std :: vec :: IntoIter < Value < Double >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < DMat2 >> for [ f64 ; 4usize ] { fn into ( self ) -> Value < DMat2 > { Value :: Concrete ( DMat2 ( self ) ) } } impl Into < Value < DMat2 >> for DMat2 { fn into ( self ) -> Value < DMat2 > { Value :: Concrete ( self ) } } impl Index < u32 > for DMat2 { type Output = f64 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for DMat2 { type Output = DMat2 ; fn into_value ( self ) -> Value < DMat2 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: DMat2 ( self . 0 ) ) ) } } # [ inline ] pub fn dmat2 < T0 , T1 > ( t0 : T0 , t1 : T1 ) -> Value < DMat2 > where T0 : IntoValue < Output = DVec2 > , T1 : IntoValue < Output = DVec2 > { let ( module , function , t0 , t1 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , ) => { return { Value :: Concrete ( DMat2 ( [ t0 . 0 , t0 . 1 , t1 . 0 , t1 . 1 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: DMAT2 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < DMat2 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < DMat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: DMAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < DMat2 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < DMat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: DMAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < DMat2 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < DMat2 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: DMAT2 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < DMat2 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < DMat2 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: DMAT2 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                          ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:17:432
[INFO] [stderr]    |
[INFO] [stderr] 17 | # [ derive ( Copy , Clone , Debug ) ] pub struct Mat3 ( pub [ f32 ; 9usize ] ) ; impl Matrix < Vec3 , Float > for Mat3 { fn identity ( ) -> Self { Mat3 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 3u32 } } impl ValueIter < Float > for Mat3 { type Iter = :: std :: vec :: IntoIter < Value < Float >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < Mat3 >> for [ f32 ; 9usize ] { fn into ( self ) -> Value < Mat3 > { Value :: Concrete ( Mat3 ( self ) ) } } impl Into < Value < Mat3 >> for Mat3 { fn into ( self ) -> Value < Mat3 > { Value :: Concrete ( self ) } } impl Index < u32 > for Mat3 { type Output = f32 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for Mat3 { type Output = Mat3 ; fn into_value ( self ) -> Value < Mat3 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: Mat3 ( self . 0 ) ) ) } } # [ inline ] pub fn mat3 < T0 , T1 , T2 > ( t0 : T0 , t1 : T1 , t2 : T2 ) -> Value < Mat3 > where T0 : IntoValue < Output = Vec3 > , T1 : IntoValue < Output = Vec3 > , T2 : IntoValue < Output = Vec3 > { let ( module , function , t0 , t1 , t2 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , ) => { return { Value :: Concrete ( Mat3 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t1 . 0 , t1 . 1 , t1 . 2 , t2 . 0 , t2 . 1 , t2 . 2 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: MAT3 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < Mat3 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < Mat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: MAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < Mat3 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < Mat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: MAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < Mat3 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < Mat3 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: MAT3 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < Mat3 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < Mat3 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: MAT3 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:19:440
[INFO] [stderr]    |
[INFO] [stderr] 19 | # [ derive ( Copy , Clone , Debug ) ] pub struct DMat3 ( pub [ f64 ; 9usize ] ) ; impl Matrix < DVec3 , Double > for DMat3 { fn identity ( ) -> Self { DMat3 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 3u32 } } impl ValueIter < Double > for DMat3 { type Iter = :: std :: vec :: IntoIter < Value < Double >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < DMat3 >> for [ f64 ; 9usize ] { fn into ( self ) -> Value < DMat3 > { Value :: Concrete ( DMat3 ( self ) ) } } impl Into < Value < DMat3 >> for DMat3 { fn into ( self ) -> Value < DMat3 > { Value :: Concrete ( self ) } } impl Index < u32 > for DMat3 { type Output = f64 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for DMat3 { type Output = DMat3 ; fn into_value ( self ) -> Value < DMat3 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: DMat3 ( self . 0 ) ) ) } } # [ inline ] pub fn dmat3 < T0 , T1 , T2 > ( t0 : T0 , t1 : T1 , t2 : T2 ) -> Value < DMat3 > where T0 : IntoValue < Output = DVec3 > , T1 : IntoValue < Output = DVec3 > , T2 : IntoValue < Output = DVec3 > { let ( module , function , t0 , t1 , t2 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , ) => { return { Value :: Concrete ( DMat3 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t1 . 0 , t1 . 1 , t1 . 2 , t2 . 0 , t2 . 1 , t2 . 2 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: DMAT3 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < DMat3 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < DMat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: DMAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < DMat3 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < DMat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: DMAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < DMat3 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < DMat3 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: DMAT3 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < DMat3 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < DMat3 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: DMAT3 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:24:475
[INFO] [stderr]    |
[INFO] [stderr] 24 | # [ derive ( Copy , Clone , Debug ) ] pub struct Mat4 ( pub [ f32 ; 16usize ] ) ; impl Matrix < Vec4 , Float > for Mat4 { fn identity ( ) -> Self { Mat4 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 4u32 } } impl ValueIter < Float > for Mat4 { type Iter = :: std :: vec :: IntoIter < Value < Float >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < Mat4 >> for [ f32 ; 16usize ] { fn into ( self ) -> Value < Mat4 > { Value :: Concrete ( Mat4 ( self ) ) } } impl Into < Value < Mat4 >> for Mat4 { fn into ( self ) -> Value < Mat4 > { Value :: Concrete ( self ) } } impl Index < u32 > for Mat4 { type Output = f32 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for Mat4 { type Output = Mat4 ; fn into_value ( self ) -> Value < Mat4 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: Mat4 ( self . 0 ) ) ) } } # [ inline ] pub fn mat4 < T0 , T1 , T2 , T3 > ( t0 : T0 , t1 : T1 , t2 : T2 , t3 : T3 ) -> Value < Mat4 > where T0 : IntoValue < Output = Vec4 > , T1 : IntoValue < Output = Vec4 > , T2 : IntoValue < Output = Vec4 > , T3 : IntoValue < Output = Vec4 > { let ( module , function , t0 , t1 , t2 , t3 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , t3 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , Value :: Concrete ( t3 ) , ) => { return { Value :: Concrete ( Mat4 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t0 . 3 , t1 . 0 , t1 . 1 , t1 . 2 , t1 . 3 , t2 . 0 , t2 . 1 , t2 . 2 , t2 . 3 , t3 . 0 , t3 . 1 , t3 . 2 , t3 . 3 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: MAT4 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; graph . add_edge ( t3 , index , 3u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < Mat4 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < Mat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: MAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < Mat4 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < Mat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: MAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < Mat4 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < Mat4 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: MAT4 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < Mat4 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < Mat4 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: MAT4 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:26:483
[INFO] [stderr]    |
[INFO] [stderr] 26 | # [ derive ( Copy , Clone , Debug ) ] pub struct DMat4 ( pub [ f64 ; 16usize ] ) ; impl Matrix < DVec4 , Double > for DMat4 { fn identity ( ) -> Self { DMat4 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 4u32 } } impl ValueIter < Double > for DMat4 { type Iter = :: std :: vec :: IntoIter < Value < Double >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < DMat4 >> for [ f64 ; 16usize ] { fn into ( self ) -> Value < DMat4 > { Value :: Concrete ( DMat4 ( self ) ) } } impl Into < Value < DMat4 >> for DMat4 { fn into ( self ) -> Value < DMat4 > { Value :: Concrete ( self ) } } impl Index < u32 > for DMat4 { type Output = f64 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for DMat4 { type Output = DMat4 ; fn into_value ( self ) -> Value < DMat4 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: DMat4 ( self . 0 ) ) ) } } # [ inline ] pub fn dmat4 < T0 , T1 , T2 , T3 > ( t0 : T0 , t1 : T1 , t2 : T2 , t3 : T3 ) -> Value < DMat4 > where T0 : IntoValue < Output = DVec4 > , T1 : IntoValue < Output = DVec4 > , T2 : IntoValue < Output = DVec4 > , T3 : IntoValue < Output = DVec4 > { let ( module , function , t0 , t1 , t2 , t3 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , t3 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , Value :: Concrete ( t3 ) , ) => { return { Value :: Concrete ( DMat4 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t0 . 3 , t1 . 0 , t1 . 1 , t1 . 2 , t1 . 3 , t2 . 0 , t2 . 1 , t2 . 2 , t2 . 3 , t3 . 0 , t3 . 1 , t3 . 2 , t3 . 3 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: DMAT4 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; graph . add_edge ( t3 , index , 3u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < DMat4 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < DMat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: DMAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < DMat4 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < DMat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: DMAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < DMat4 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < DMat4 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: DMAT4 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < DMat4 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < DMat4 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: DMAT4 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:10:402
[INFO] [stderr]    |
[INFO] [stderr] 10 | # [ derive ( Copy , Clone , Debug ) ] pub struct Mat2 ( pub [ f32 ; 4usize ] ) ; impl Matrix < Vec2 , Float > for Mat2 { fn identity ( ) -> Self { Mat2 ( [ 1.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 2u32 } } impl ValueIter < Float > for Mat2 { type Iter = :: std :: vec :: IntoIter < Value < Float >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < Mat2 >> for [ f32 ; 4usize ] { fn into ( self ) -> Value < Mat2 > { Value :: Concrete ( Mat2 ( self ) ) } } impl Into < Value < Mat2 >> for Mat2 { fn into ( self ) -> Value < Mat2 > { Value :: Concrete ( self ) } } impl Index < u32 > for Mat2 { type Output = f32 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for Mat2 { type Output = Mat2 ; fn into_value ( self ) -> Value < Mat2 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: Mat2 ( self . 0 ) ) ) } } # [ inline ] pub fn mat2 < T0 , T1 > ( t0 : T0 , t1 : T1 ) -> Value < Mat2 > where T0 : IntoValue < Output = Vec2 > , T1 : IntoValue < Output = Vec2 > { let ( module , function , t0 , t1 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , ) => { return { Value :: Concrete ( Mat2 ( [ t0 . 0 , t0 . 1 , t1 . 0 , t1 . 1 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: MAT2 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < Mat2 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < Mat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: MAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < Mat2 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < Mat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: MAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < Mat2 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < Mat2 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: MAT2 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < Mat2 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < Mat2 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: MAT2 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                  ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(array_into_iter)]` on by default
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:12:410
[INFO] [stderr]    |
[INFO] [stderr] 12 | # [ derive ( Copy , Clone , Debug ) ] pub struct DMat2 ( pub [ f64 ; 4usize ] ) ; impl Matrix < DVec2 , Double > for DMat2 { fn identity ( ) -> Self { DMat2 ( [ 1.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 2u32 } } impl ValueIter < Double > for DMat2 { type Iter = :: std :: vec :: IntoIter < Value < Double >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < DMat2 >> for [ f64 ; 4usize ] { fn into ( self ) -> Value < DMat2 > { Value :: Concrete ( DMat2 ( self ) ) } } impl Into < Value < DMat2 >> for DMat2 { fn into ( self ) -> Value < DMat2 > { Value :: Concrete ( self ) } } impl Index < u32 > for DMat2 { type Output = f64 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for DMat2 { type Output = DMat2 ; fn into_value ( self ) -> Value < DMat2 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: DMat2 ( self . 0 ) ) ) } } # [ inline ] pub fn dmat2 < T0 , T1 > ( t0 : T0 , t1 : T1 ) -> Value < DMat2 > where T0 : IntoValue < Output = DVec2 > , T1 : IntoValue < Output = DVec2 > { let ( module , function , t0 , t1 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , ) => { return { Value :: Concrete ( DMat2 ( [ t0 . 0 , t0 . 1 , t1 . 0 , t1 . 1 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; ( module , function , tmp_0 , tmp_1 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: DMAT2 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < DMat2 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < DMat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: DMAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < DMat2 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < DMat2 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: DMAT2 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < DMat2 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < DMat2 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: DMAT2 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < DMat2 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < DMat2 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: DMAT2 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                          ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:17:432
[INFO] [stderr]    |
[INFO] [stderr] 17 | # [ derive ( Copy , Clone , Debug ) ] pub struct Mat3 ( pub [ f32 ; 9usize ] ) ; impl Matrix < Vec3 , Float > for Mat3 { fn identity ( ) -> Self { Mat3 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 3u32 } } impl ValueIter < Float > for Mat3 { type Iter = :: std :: vec :: IntoIter < Value < Float >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < Mat3 >> for [ f32 ; 9usize ] { fn into ( self ) -> Value < Mat3 > { Value :: Concrete ( Mat3 ( self ) ) } } impl Into < Value < Mat3 >> for Mat3 { fn into ( self ) -> Value < Mat3 > { Value :: Concrete ( self ) } } impl Index < u32 > for Mat3 { type Output = f32 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for Mat3 { type Output = Mat3 ; fn into_value ( self ) -> Value < Mat3 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: Mat3 ( self . 0 ) ) ) } } # [ inline ] pub fn mat3 < T0 , T1 , T2 > ( t0 : T0 , t1 : T1 , t2 : T2 ) -> Value < Mat3 > where T0 : IntoValue < Output = Vec3 > , T1 : IntoValue < Output = Vec3 > , T2 : IntoValue < Output = Vec3 > { let ( module , function , t0 , t1 , t2 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , ) => { return { Value :: Concrete ( Mat3 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t1 . 0 , t1 . 1 , t1 . 2 , t2 . 0 , t2 . 1 , t2 . 2 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: MAT3 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < Mat3 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < Mat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: MAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < Mat3 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < Mat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: MAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < Mat3 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < Mat3 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: MAT3 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < Mat3 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < Mat3 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: MAT3 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:19:440
[INFO] [stderr]    |
[INFO] [stderr] 19 | # [ derive ( Copy , Clone , Debug ) ] pub struct DMat3 ( pub [ f64 ; 9usize ] ) ; impl Matrix < DVec3 , Double > for DMat3 { fn identity ( ) -> Self { DMat3 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 3u32 } } impl ValueIter < Double > for DMat3 { type Iter = :: std :: vec :: IntoIter < Value < Double >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < DMat3 >> for [ f64 ; 9usize ] { fn into ( self ) -> Value < DMat3 > { Value :: Concrete ( DMat3 ( self ) ) } } impl Into < Value < DMat3 >> for DMat3 { fn into ( self ) -> Value < DMat3 > { Value :: Concrete ( self ) } } impl Index < u32 > for DMat3 { type Output = f64 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for DMat3 { type Output = DMat3 ; fn into_value ( self ) -> Value < DMat3 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: DMat3 ( self . 0 ) ) ) } } # [ inline ] pub fn dmat3 < T0 , T1 , T2 > ( t0 : T0 , t1 : T1 , t2 : T2 ) -> Value < DMat3 > where T0 : IntoValue < Output = DVec3 > , T1 : IntoValue < Output = DVec3 > , T2 : IntoValue < Output = DVec3 > { let ( module , function , t0 , t1 , t2 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , ) => { return { Value :: Concrete ( DMat3 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t1 . 0 , t1 . 1 , t1 . 2 , t2 . 0 , t2 . 1 , t2 . 2 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; ( module , function , tmp_0 , tmp_1 , tmp_2 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: DMAT3 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < DMat3 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < DMat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: DMAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < DMat3 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < DMat3 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: DMAT3 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < DMat3 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < DMat3 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: DMAT3 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < DMat3 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < DMat3 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: DMAT3 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:24:475
[INFO] [stderr]    |
[INFO] [stderr] 24 | # [ derive ( Copy , Clone , Debug ) ] pub struct Mat4 ( pub [ f32 ; 16usize ] ) ; impl Matrix < Vec4 , Float > for Mat4 { fn identity ( ) -> Self { Mat4 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 4u32 } } impl ValueIter < Float > for Mat4 { type Iter = :: std :: vec :: IntoIter < Value < Float >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < Mat4 >> for [ f32 ; 16usize ] { fn into ( self ) -> Value < Mat4 > { Value :: Concrete ( Mat4 ( self ) ) } } impl Into < Value < Mat4 >> for Mat4 { fn into ( self ) -> Value < Mat4 > { Value :: Concrete ( self ) } } impl Index < u32 > for Mat4 { type Output = f32 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for Mat4 { type Output = Mat4 ; fn into_value ( self ) -> Value < Mat4 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: Mat4 ( self . 0 ) ) ) } } # [ inline ] pub fn mat4 < T0 , T1 , T2 , T3 > ( t0 : T0 , t1 : T1 , t2 : T2 , t3 : T3 ) -> Value < Mat4 > where T0 : IntoValue < Output = Vec4 > , T1 : IntoValue < Output = Vec4 > , T2 : IntoValue < Output = Vec4 > , T3 : IntoValue < Output = Vec4 > { let ( module , function , t0 , t1 , t2 , t3 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , t3 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , Value :: Concrete ( t3 ) , ) => { return { Value :: Concrete ( Mat4 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t0 . 3 , t1 . 0 , t1 . 1 , t1 . 2 , t1 . 3 , t2 . 0 , t2 . 1 , t2 . 2 , t2 . 3 , t3 . 0 , t3 . 1 , t3 . 2 , t3 . 3 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: MAT4 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; graph . add_edge ( t3 , index , 3u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < Mat4 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < Mat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: MAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < Mat4 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < Mat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: MAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < Mat4 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < Mat4 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: MAT4 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < Mat4 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < Mat4 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: MAT4 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/rasen-dsl-d58a5756fabeef77/out/types.rs:26:483
[INFO] [stderr]    |
[INFO] [stderr] 26 | # [ derive ( Copy , Clone , Debug ) ] pub struct DMat4 ( pub [ f64 ; 16usize ] ) ; impl Matrix < DVec4 , Double > for DMat4 { fn identity ( ) -> Self { DMat4 ( [ 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 , ] ) } fn column_count ( ) -> u32 { 4u32 } } impl ValueIter < Double > for DMat4 { type Iter = :: std :: vec :: IntoIter < Value < Double >> ; fn iter < 'a > ( obj : & Self ) -> Self :: Iter { let lst : Vec < _ > = obj . 0 . into_iter ( ) . map ( | s | s . into ( ) ) . collect ( ) ; lst . into_iter ( ) } } impl Into < Value < DMat4 >> for [ f64 ; 16usize ] { fn into ( self ) -> Value < DMat4 > { Value :: Concrete ( DMat4 ( self ) ) } } impl Into < Value < DMat4 >> for DMat4 { fn into ( self ) -> Value < DMat4 > { Value :: Concrete ( self ) } } impl Index < u32 > for DMat4 { type Output = f64 ; fn index ( & self , index : u32 ) -> & Self :: Output { & self . 0 [ index as usize ] } } impl IntoValue for DMat4 { type Output = DMat4 ; fn into_value ( self ) -> Value < DMat4 > { Value :: Concrete ( self ) } fn get_index ( & self , mut graph : GraphRef ) -> NodeIndex < u32 > { graph . add_node ( Node :: Constant ( TypedValue :: DMat4 ( self . 0 ) ) ) } } # [ inline ] pub fn dmat4 < T0 , T1 , T2 , T3 > ( t0 : T0 , t1 : T1 , t2 : T2 , t3 : T3 ) -> Value < DMat4 > where T0 : IntoValue < Output = DVec4 > , T1 : IntoValue < Output = DVec4 > , T2 : IntoValue < Output = DVec4 > , T3 : IntoValue < Output = DVec4 > { let ( module , function , t0 , t1 , t2 , t3 ) = match ( t0 . into_value ( ) , t1 . into_value ( ) , t2 . into_value ( ) , t3 . into_value ( ) , ) { ( Value :: Concrete ( t0 ) , Value :: Concrete ( t1 ) , Value :: Concrete ( t2 ) , Value :: Concrete ( t3 ) , ) => { return { Value :: Concrete ( DMat4 ( [ t0 . 0 , t0 . 1 , t0 . 2 , t0 . 3 , t1 . 0 , t1 . 1 , t1 . 2 , t1 . 3 , t2 . 0 , t2 . 1 , t2 . 2 , t2 . 3 , t3 . 0 , t3 . 1 , t3 . 2 , t3 . 3 ] ) ) } } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , t3 @ Value :: Concrete ( _ ) , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t3 . get_index ( graph ) } ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , t2 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t2 . get_index ( graph ) } ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , t1 @ Value :: Concrete ( _ ) , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t1 . get_index ( graph ) } ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( t0 @ Value :: Concrete ( _ ) , Value :: Abstract { module , function , index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = { let module = module . borrow_mut ( ) ; let graph = function . get_graph_mut ( module ) ; t0 . get_index ( graph ) } ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , ( Value :: Abstract { module , function , index : t0 , .. } , Value :: Abstract { index : t1 , .. } , Value :: Abstract { index : t2 , .. } , Value :: Abstract { index : t3 , .. } , ) => { let tmp_0 = t0 ; let tmp_1 = t1 ; let tmp_2 = t2 ; let tmp_3 = t3 ; ( module , function , tmp_0 , tmp_1 , tmp_2 , tmp_3 ) } , } ; let index = { let module = module . borrow_mut ( ) ; let mut graph = function . get_graph_mut ( module ) ; let index = graph . add_node ( Node :: Construct ( TypeName :: DMAT4 ) ) ; graph . add_edge ( t0 , index , 0u32 ) ; graph . add_edge ( t1 , index , 1u32 ) ; graph . add_edge ( t2 , index , 2u32 ) ; graph . add_edge ( t3 , index , 3u32 ) ; index } ; Value :: Abstract { module , function , index , ty : PhantomData , } } impl Input < DMat4 > for Module { # [ inline ] fn input < N > ( & self , location : u32 , name : N ) -> Value < DMat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Input ( location , TypeName :: DMAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Uniform < DMat4 > for Module { # [ inline ] fn uniform < N > ( & self , location : u32 , name : N ) -> Value < DMat4 > where N : Into < NameWrapper > { let index = { let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; module . main . add_node ( Node :: Uniform ( location , TypeName :: DMAT4 , name ) ) } ; Value :: Abstract { module : self . clone ( ) , function : FuncKind :: Main , index , ty : PhantomData , } } } impl Output < DMat4 > for Module { # [ inline ] fn output < N > ( & self , location : u32 , name : N , source : Value < DMat4 > ) where N : Into < NameWrapper > { let src = match source { Value :: Abstract { index , .. } => index , source @ Value :: Concrete ( _ ) => { let module = self . borrow_mut ( ) ; let graph = FuncKind :: Main . get_graph_mut ( module ) ; source . get_index ( graph ) } , } ; let mut module = self . borrow_mut ( ) ; let NameWrapper ( name ) = name . into ( ) ; let sink = module . main . add_node ( Node :: Output ( location , TypeName :: DMAT4 , name ) ) ; module . main . add_edge ( src , sink , 0 ) ; } } impl < F > Parameter < DMat4 > for Function < F > { # [ inline ] fn parameter ( & self , location : u32 ) -> Value < DMat4 > { let index = { let mut module = self . module . borrow_mut ( ) ; let graph = & mut module [ self . func ] ; graph . add_node ( Node :: Parameter ( location , TypeName :: DMAT4 ) ) } ; Value :: Abstract { module : self . module . clone ( ) , function : FuncKind :: Ref ( self . func ) , index , ty : PhantomData , } } }
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stderr]    |
[INFO] [stderr]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stderr]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stderr] 
[INFO] [stderr] error: couldn't read tests/../../tests/dsl.rs: No such file or directory (os error 2)
[INFO] [stderr]  --> tests/exec.rs:9:1
[INFO] [stderr]   |
[INFO] [stderr] 9 | include!("../../tests/dsl.rs");
[INFO] [stderr]   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] error: aborting due to previous error
[INFO] [stderr] 
[INFO] [stderr] error: could not compile `rasen-dsl`.
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] error: couldn't read benches/../../tests/dsl.rs: No such file or directory (os error 2)
[INFO] [stderr]   --> benches/exec.rs:10:1
[INFO] [stderr]    |
[INFO] [stderr] 10 | include!("../../tests/dsl.rs");
[INFO] [stderr]    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] error: aborting due to previous error
[INFO] [stderr] 
[INFO] [stderr] error: could not compile `rasen-dsl`.
[INFO] [stderr] 
[INFO] [stderr] To learn more, run the command again with --verbose.
[INFO] running `"docker" "inspect" "bfb162ecf67e534ac0ffe26f8f35e85a7464de9b7e1a7d5e5e35e5ddf08dbd61"`
[INFO] running `"docker" "rm" "-f" "bfb162ecf67e534ac0ffe26f8f35e85a7464de9b7e1a7d5e5e35e5ddf08dbd61"`
[INFO] [stdout] bfb162ecf67e534ac0ffe26f8f35e85a7464de9b7e1a7d5e5e35e5ddf08dbd61