1  program module_resolution_corner.alpha {
 2      struct Wrapper {
 3          outer: base::Foo,
 4          inner: base::nested::Foo::[3],
 5      }
 6  
 7      transition main() -> u32 {
 8          let outer_x = base::X;
 9          let inner_x = base::nested::X;
10          let deep_x = base::nested::deeper::X;
11  
12          let f1 = base::Foo {
13              a: [1; base::X],
14          };
15  
16          let f2 = base::nested::Foo::[3] {
17              a: [2; 3],
18          };
19  
20          let f3 = base::nested::deeper::Foo::[base::nested::deeper::X] {
21              a: [3; base::nested::deeper::X],
22          };
23  
24          return outer_x + inner_x + deep_x
25               + f1.a[0] + f2.a[1] + f3.a[2]
26               + base::nested::compute()
27               + base::nested::deeper::compute();
28      }
29  }
30  
31  // --- Next Module: base.leo --- //
32  
33  const X: u32 = 2;
34  
35  struct Foo {
36      a: [u32; X],
37  }
38  
39  // --- Next Module: base/nested.leo --- //
40  
41  const X: u32 = 3;
42  
43  struct Foo::[N: u32] {
44      a: [u32; N],
45  }
46  
47  inline compute() -> u32 {
48      let b = Foo::[X] {
49          a: [10; X],
50      };
51      return b.a[1] + deeper::X + deeper::compute();
52  }
53  
54  // --- Next Module: base/nested/deeper.leo --- //
55  
56  const X: u32 = 4;
57  
58  struct Foo::[M: u32] {
59      a: [u32; M],
60  }
61  
62  inline compute() -> u32 {
63      let f = Foo::[X] {
64          a: [20; X],
65      };
66      return X + f.a[2];
67  }
68