Add new metaprogramming tests

src/exo/frontend/pyparser.py

@@ -1260,7 +1260,7 @@ def parse_array_indexing(self, node):
 
             def unquote_to_index(unquoted, ref_node, srcinfo, top_level):
                 if isinstance(unquoted, (int, float)):
-                    return self.AST.Const(unquoted, self.getsrcinfo(e))
+                    return self.AST.Const(unquoted, srcinfo)
                 elif isinstance(unquoted, ExoExpression) and isinstance(
                     unquoted._inner, self.AST.expr
                 ):
@@ -1271,12 +1271,16 @@ def unquote_to_index(unquoted, ref_node, srcinfo, top_level):
                             (
                                 None
                                 if unquoted.start is None
-                                else unquote_to_index(unquoted.start, False)
+                                else unquote_to_index(
+                                    unquoted.start, ref_node, srcinfo, False
+                                )
                             ),
                             (
                                 None
                                 if unquoted.stop is None
-                                else unquote_to_index(unquoted.stop, False)
+                                else unquote_to_index(
+                                    unquoted.stop, ref_node, srcinfo, False
+                                )
                             ),
                             srcinfo,
                         )

tests/golden/test_metaprogramming/test_quote_complex_expr.txt

@@ -0,0 +1,16 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// foo(
+//     a : i32 @DRAM
+// )
+void foo( void *ctxt, int32_t* a ) {
+*a = *a + ((int32_t) 1) + ((int32_t) 1);
+}
+

tests/golden/test_metaprogramming/test_quote_elision.txt

@@ -0,0 +1,17 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// foo(
+//     a : i32 @DRAM,
+//     b : i32 @DRAM
+// )
+void foo( void *ctxt, const int32_t* a, int32_t* b ) {
+*b = *a;
+}
+

tests/golden/test_metaprogramming/test_scope_collision1.txt

@@ -0,0 +1,18 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// foo(
+//     a : i32 @DRAM
+// )
+void foo( void *ctxt, int32_t* a ) {
+int32_t b;
+b = ((int32_t) 2);
+*a = ((int32_t) 1);
+}
+

tests/golden/test_metaprogramming/test_scope_collision2.txt

@@ -0,0 +1,17 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// foo(
+//     a : i32 @DRAM,
+//     b : i32 @DRAM
+// )
+void foo( void *ctxt, const int32_t* a, int32_t* b ) {
+*b = *a;
+}
+

tests/golden/test_metaprogramming/test_statement_assignment.txt

@@ -0,0 +1,19 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// foo(
+//     a : i32 @DRAM
+// )
+void foo( void *ctxt, int32_t* a ) {
+*a += ((int32_t) 1);
+*a += ((int32_t) 2);
+*a += ((int32_t) 1);
+*a += ((int32_t) 2);
+}
+

tests/golden/test_metaprogramming/test_type_quote_elision.txt

@@ -0,0 +1,18 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// foo(
+//     a : i8 @DRAM,
+//     x : i8[2] @DRAM
+// )
+void foo( void *ctxt, int8_t* a, const int8_t* x ) {
+*a += x[0];
+*a += x[1];
+}
+

tests/golden/test_metaprogramming/test_unquote_elision.txt

@@ -0,0 +1,16 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// foo(
+//     a : i32 @DRAM
+// )
+void foo( void *ctxt, int32_t* a ) {
+*a = *a * ((int32_t) 2);
+}
+

tests/golden/test_metaprogramming/test_unquote_in_slice.txt

@@ -0,0 +1,25 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// bar(
+//     a : i8[10, 10] @DRAM
+// )
+void bar( void *ctxt, int8_t* a ) {
+for (int_fast32_t i = 0; i < 5; i++) {
+  foo(ctxt,(struct exo_win_1i8){ &a[(i) * (10) + 2], { 1 } });
+}
+}
+
+// foo(
+//     a : [i8][2] @DRAM
+// )
+void foo( void *ctxt, struct exo_win_1i8 a ) {
+a.data[0] += a.data[a.strides[0]];
+}
+

tests/golden/test_metaprogramming/test_unquote_index_tuple.txt

@@ -0,0 +1,26 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// bar(
+//     a : i8[10, 10, 10] @DRAM
+// )
+void bar( void *ctxt, int8_t* a ) {
+for (int_fast32_t i = 0; i < 7; i++) {
+  foo(ctxt,(struct exo_win_2i8){ &a[(i) * (100) + (i) * (10) + i + 1], { 10, 1 } });
+}
+}
+
+// foo(
+//     a : [i8][2, 2] @DRAM
+// )
+void foo( void *ctxt, struct exo_win_2i8 a ) {
+a.data[0] += a.data[a.strides[1]];
+a.data[a.strides[0]] += a.data[a.strides[0] + a.strides[1]];
+}
+

tests/golden/test_metaprogramming/test_unquote_slice_object1.txt

@@ -0,0 +1,31 @@
+#include "test.h"
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// bar(
+//     a : i8[10, 10] @DRAM
+// )
+void bar( void *ctxt, int8_t* a ) {
+for (int_fast32_t i = 0; i < 10; i++) {
+  foo(ctxt,(struct exo_win_1i8){ &a[(i) * (10) + 1], { 1 } });
+}
+for (int_fast32_t i = 0; i < 10; i++) {
+  foo(ctxt,(struct exo_win_1i8){ &a[(i) * (10) + 5], { 1 } });
+}
+for (int_fast32_t i = 0; i < 10; i++) {
+  foo(ctxt,(struct exo_win_1i8){ &a[(i) * (10) + 2], { 1 } });
+}
+}
+
+// foo(
+//     a : [i8][2] @DRAM
+// )
+void foo( void *ctxt, struct exo_win_1i8 a ) {
+a.data[0] += a.data[a.strides[0]];
+}
+