diff --git a/proto-tests/test_fem_assembly.py b/proto-tests/test_fem_assembly.py
index b52ec460119d105de1616c9175d013652fa90946..0a28d5ccbdf634901f3d3262a541bd07d5baa473 100644
--- a/proto-tests/test_fem_assembly.py
+++ b/proto-tests/test_fem_assembly.py
@@ -25,7 +25,7 @@ def test_laplacian_stiffness(ctx_factory):
     knl = lp.make_kernel(ctx.devices[0],
             "[Nc] -> {[K,i,j,q, dx_axis, ax_b]: 0<=K<Nc and 0<=i,j<%(Nb)d and 0<=q<%(Nq)d "  # noqa
             "and 0<= dx_axis, ax_b < %(dim)d}"
-            % dict(Nb=Nb, Nq=Nq, dim=dim),
+            % {"Nb": Nb, "Nq": Nq, "dim": dim},
             [
                 "dPsi(ij, dxi) := sum_float32(@ax_b,"
                     "  jacInv[ax_b,dxi,K,q] * DPsi[ax_b,ij,q])",
@@ -42,7 +42,7 @@ def test_laplacian_stiffness(ctx_factory):
             ],
             name="lapquad", assumptions="Nc>=1")
 
-    knl = lp.tag_inames(knl, dict(ax_b="unr"))
+    knl = lp.tag_inames(knl, {"ax_b": "unr"})
     seq_knl = knl
 
     def variant_fig31(knl):
@@ -123,7 +123,7 @@ def test_laplacian_stiffness(ctx_factory):
         var_knl, loop_prio = variant(knl)
         kernel_gen = lp.generate_loop_schedules(var_knl,
                 loop_priority=loop_prio)
-        kernel_gen = lp.check_kernels(kernel_gen, dict(Nc=Nc))
+        kernel_gen = lp.check_kernels(kernel_gen, {"Nc": Nc})
 
         # print lp.preprocess_kernel(var_knl)
 
diff --git a/proto-tests/test_sem.py b/proto-tests/test_sem.py
index b4d85411bd51472b3577a0619b31f68039e4e886..b1a2a9a22a8f1689e798a1e5cf0be080e13ec035 100644
--- a/proto-tests/test_sem.py
+++ b/proto-tests/test_sem.py
@@ -96,11 +96,11 @@ def test_laplacian(ctx_factory):
     # print lp.preprocess_kernel(knl)
     # 1/0
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     kernel_gen = lp.generate_loop_schedules(knl,
             loop_priority=["m_fetch_G", "i_fetch_u"])
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -173,10 +173,10 @@ def test_laplacian_lmem(ctx_factory):
     # print lp.preprocess_kernel(knl)
     # 1/0
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -246,10 +246,10 @@ def test_laplacian_lmem_ilp(ctx_factory):
     # print seq_knl
     # 1/0
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     for knl in kernel_gen:
         print(lp.generate_code(knl))
@@ -333,10 +333,10 @@ def test_advect(ctx_factory):
 
     knl = lp.split_iname(knl, "e", 16, outer_tag="g.0")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000), kill_level_min=5)
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000}, kill_level_min=5)
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -446,13 +446,13 @@ def test_advect_dealias(ctx_factory):
 
     knl = lp.split_iname(knl, "e", 16, outer_tag="g.0")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     print(knl)
     # 1/0
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000), kill_level_min=5)
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000}, kill_level_min=5)
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(knl, ctx, kernel_gen,
@@ -507,13 +507,13 @@ def test_interp_diff(ctx_factory):
 
     knl = lp.split_iname(knl, "e", 16, outer_tag="g.0")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     print(knl)
     # 1/0
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000), kill_level_min=5)
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000}, kill_level_min=5)
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(knl, ctx, kernel_gen,
diff --git a/proto-tests/test_sem_tim.py b/proto-tests/test_sem_tim.py
index a42f1aa8cf7d9d41dd66aa6519c3bc437be408c2..97dc03be93550aad68c1925aadbd756e9cf5cd75 100644
--- a/proto-tests/test_sem_tim.py
+++ b/proto-tests/test_sem_tim.py
@@ -98,11 +98,11 @@ def test_laplacian(ctx_factory):
     # print(lp.preprocess_kernel(knl))
     # 1/0
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     kernel_gen = lp.generate_loop_schedules(knl,
             loop_priority=["m_fetch_G", "i_fetch_u"])
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -188,7 +188,7 @@ def test_laplacian_lmem(ctx_factory):
 #    knl = lp.tag_inames(knl, dict(i_and_j="l.0", k="l.1"))
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -254,10 +254,10 @@ def test_laplacian_lmem_ilp(ctx_factory):
     # print(seq_knl)
     # 1/0
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     for knl in kernel_gen:
         print(lp.generate_code(knl))
@@ -341,10 +341,10 @@ def test_advect(ctx_factory):
 
     knl = lp.split_iname(knl, "e", 16, outer_tag="g.0")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000), kill_level_min=5)
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000}, kill_level_min=5)
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -454,13 +454,13 @@ def test_advect_dealias(ctx_factory):
 
     knl = lp.split_iname(knl, "e", 16, outer_tag="g.0")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     print(knl)
     # 1/0
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000), kill_level_min=5)
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000}, kill_level_min=5)
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(knl, ctx, kernel_gen,
@@ -515,13 +515,13 @@ def test_interp_diff(ctx_factory):
 
     knl = lp.split_iname(knl, "e", 16, outer_tag="g.0")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
 
     print(knl)
     # 1/0
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000), kill_level_min=5)
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000}, kill_level_min=5)
 
     K = 1000  # noqa
 
diff --git a/proto-tests/test_tim.py b/proto-tests/test_tim.py
index 3926101473ea4a8ac06383650fb0b66076991fb7..a5bea3ac47d69966452ed8e7a2ec440c43c52dc1 100644
--- a/proto-tests/test_tim.py
+++ b/proto-tests/test_tim.py
@@ -53,16 +53,16 @@ def test_tim2d(ctx_factory):
     knl = lp.precompute(knl, "us", np.float32, ["a", "b"], default_tag="l.auto")
     knl = lp.split_iname(knl, "e", 1, outer_tag="g.0")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="l.1"))
-    knl = lp.tag_inames(knl, dict(o="unr"))
-    knl = lp.tag_inames(knl, dict(m="unr"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1"})
+    knl = lp.tag_inames(knl, {"o": "unr"})
+    knl = lp.tag_inames(knl, {"m": "unr"})
 
 
 #    knl = lp.add_prefetch(knl, "G", [2,3], default_tag=None) # axis/argument indices on G  # noqa
     knl = lp.add_prefetch(knl, "G", [2, 3], default_tag="l.auto")  # axis/argument indices on G  # noqa
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -118,13 +118,13 @@ def test_red2d(ctx_factory):
     knl = lp.split_iname(knl, "j", n, inner_tag="l.0")  # , slabs=(0, 1))
     knl = lp.split_iname(knl, "i", n, inner_tag="l.1")  # , slabs=(0, 1))
 
-    knl = lp.tag_inames(knl, dict(o="unr"))
-    knl = lp.tag_inames(knl, dict(m="unr"))
+    knl = lp.tag_inames(knl, {"o": "unr"})
+    knl = lp.tag_inames(knl, {"m": "unr"})
 
     knl = lp.add_prefetch(knl, "G", [2, 3], default_tag="l.auto")  # axis/argument indices on G  # noqa
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     K = 1000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
@@ -188,14 +188,14 @@ def test_tim3d(ctx_factory):
 
 #    knl = lp.tag_inames(knl, dict(k_inner="unr"))
 
-    knl = lp.tag_inames(knl, dict(o="unr"))
-    knl = lp.tag_inames(knl, dict(m="unr"))
+    knl = lp.tag_inames(knl, {"o": "unr"})
+    knl = lp.tag_inames(knl, {"m": "unr"})
 #    knl = lp.tag_inames(knl, dict(i="unr"))
 
     knl = lp.add_prefetch(knl, "G", [2, 3, 4], default_tag="l.auto")  # axis/argument indices on G  # noqa
 
     kernel_gen = lp.generate_loop_schedules(knl)
-    kernel_gen = lp.check_kernels(kernel_gen, dict(K=1000))
+    kernel_gen = lp.check_kernels(kernel_gen, {"K": 1000})
 
     K = 4000  # noqa
     lp.auto_test_vs_ref(seq_knl, ctx, kernel_gen,
diff --git a/pyproject.toml b/pyproject.toml
index 3478c608c3294aa5509b264227353bb54e512986..7012d63630e7ce881f6dda8b978441d7bad5826b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -111,7 +111,6 @@ extend-ignore = [
 
     # FIXME
     "NPY002", # numpy rng
-    "C408", # unnecssary dict() -> literal
 ]
 
 [tool.ruff.lint.per-file-ignores]
diff --git a/test/gnuma_loopy_transforms.py b/test/gnuma_loopy_transforms.py
index 9c4400406d7b2cd8ecc1a7262128bbee8463eeef..1b8842a661189edea34e6742f4f52b4e3eeb1788 100644
--- a/test/gnuma_loopy_transforms.py
+++ b/test/gnuma_loopy_transforms.py
@@ -39,6 +39,6 @@ def set_D_storage_format(kernel):  # noqa: N802
 def set_up_volume_loop(kernel, Nq):  # noqa
     kernel = lp.fix_parameters(kernel, Nq=Nq)
     kernel = lp.prioritize_loops(kernel, "e,k,j,i")
-    kernel = lp.tag_inames(kernel, dict(e="g.0", j="l.1", i="l.0"))
+    kernel = lp.tag_inames(kernel, {"e": "g.0", "j": "l.1", "i": "l.0"})
     kernel = lp.assume(kernel, "elements >= 1")
     return kernel
diff --git a/test/test_apps.py b/test/test_apps.py
index 11422971dc82831d68520255013527e0488400eb..8c32aa9ac4acf346d1da3059aa8edef460dd0c2d 100644
--- a/test/test_apps.py
+++ b/test/test_apps.py
@@ -102,7 +102,7 @@ def test_convolution(ctx_factory):
     def variant_2(knl):
         knl = lp.split_iname(knl, "im_x", 16, outer_tag="g.0", inner_tag="l.0")
         knl = lp.split_iname(knl, "im_y", 16, outer_tag="g.1", inner_tag="l.1")
-        knl = lp.tag_inames(knl, dict(ifeat="g.2"))
+        knl = lp.tag_inames(knl, {"ifeat": "g.2"})
         knl = lp.add_prefetch(knl, "f[ifeat,:,:,:]",
                 fetch_outer_inames="im_x_outer, im_y_outer, ifeat",
                 default_tag="l.auto")
@@ -117,10 +117,10 @@ def test_convolution(ctx_factory):
             variant_2
             ]:
         lp.auto_test_vs_ref(ref_knl, ctx, variant(knl),
-                parameters=dict(
-                    im_w=128, im_h=128, f_w=f_w,
-                    nfeats=3, nimgs=3
-                    ))
+                parameters={
+                    "im_w": 128, "im_h": 128, "f_w": f_w,
+                    "nfeats": 3, "nimgs": 3
+                    })
 
 
 def test_convolution_with_nonzero_base(ctx_factory):
@@ -175,10 +175,10 @@ def test_convolution_with_nonzero_base(ctx_factory):
             variant_1,
             ]:
         lp.auto_test_vs_ref(ref_knl, ctx, variant(knl),
-                parameters=dict(
-                    im_w=128, im_h=128, f_w=f_w,
-                    nfeats=12, nimgs=17
-                    ))
+                parameters={
+                    "im_w": 128, "im_h": 128, "f_w": f_w,
+                    "nfeats": 12, "nimgs": 17
+                    })
 
 # }}}
 
@@ -227,12 +227,12 @@ def test_rob_stroud_bernstein():
     knl = lp.split_iname(knl, "el", 16, inner_tag="l.0")
     knl = lp.split_iname(knl, "el_outer", 2, outer_tag="g.0", inner_tag="ilp",
             slabs=(0, 1))
-    knl = lp.tag_inames(knl, dict(i2="l.1", alpha1="unr", alpha2="unr"))
-    knl = lp.add_dtypes(knl, dict(
-                qpts=np.float32,
-                coeffs=np.float32,
-                tmp=np.float32,
-                ))
+    knl = lp.tag_inames(knl, {"i2": "l.1", "alpha1": "unr", "alpha2": "unr"})
+    knl = lp.add_dtypes(knl, {
+                "qpts": np.float32,
+                "coeffs": np.float32,
+                "tmp": np.float32,
+                })
     print(lp.generate_code_v2(knl))
 
 
@@ -306,18 +306,18 @@ def test_rob_stroud_bernstein_full():
         knl = lp.split_iname(knl, "el", 16, inner_tag="l.0")
         knl = lp.split_iname(knl, "el_outer", 2, outer_tag="g.0", inner_tag="ilp",
                 slabs=(0, 1))
-        knl = lp.tag_inames(knl, dict(i2="l.1", alpha1="unr", alpha2="unr"))
+        knl = lp.tag_inames(knl, {"i2": "l.1", "alpha1": "unr", "alpha2": "unr"})
 
     from pickle import dumps, loads
     knl = loads(dumps(knl))
 
     knl = lp.add_dtypes(knl,
-            dict(
-                qpts=np.float32,
-                tmp=np.float32,
-                coeffs=np.float32,
-                result=np.float32,
-                ))
+            {
+                "qpts": np.float32,
+                "tmp": np.float32,
+                "coeffs": np.float32,
+                "result": np.float32,
+                })
     print(lp.generate_code_v2(knl))
 
 
@@ -393,7 +393,7 @@ def test_stencil_with_overfetch(ctx_factory):
         # https://github.com/pocl/pocl/issues/205
         pytest.skip("takes very long to compile on pocl")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32})
 
     ref_knl = knl
 
@@ -411,7 +411,7 @@ def test_stencil_with_overfetch(ctx_factory):
         n = 200
         lp.auto_test_vs_ref(ref_knl, ctx, variant(knl),
                 print_ref_code=False,
-                op_count=[n*n], parameters=dict(n=n), op_label=["cells"])
+                op_count=[n*n], parameters={"n": n}, op_label=["cells"])
 
 
 def test_sum_factorization():
@@ -531,7 +531,7 @@ def test_fd_demo():
     # u = cl.clrandom.rand(queue, (n+2, n+2), dtype=np.float32)
 
     knl = lp.set_options(knl, write_code=True)
-    knl = lp.add_and_infer_dtypes(knl, dict(u=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"u": np.float32})
     code, _inf = lp.generate_code(knl)
     print(code)
 
@@ -555,7 +555,7 @@ def test_fd_1d(ctx_factory):
 
     lp.auto_test_vs_ref(
             ref_knl, ctx, knl,
-            parameters=dict(n=2048))
+            parameters={"n": 2048})
 
 
 def test_poisson_fem(ctx_factory):
@@ -600,12 +600,12 @@ def test_poisson_fem(ctx_factory):
         return knl
 
     def add_types(knl):
-        return lp.add_and_infer_dtypes(knl, dict(
-            w=np.float32,
-            J=np.float32,
-            DPsi=np.float32,
-            DFinv=np.float32,
-            ))
+        return lp.add_and_infer_dtypes(knl, {
+            "w": np.float32,
+            "J": np.float32,
+            "DPsi": np.float32,
+            "DFinv": np.float32,
+            })
 
     for variant in [
             # variant_1,
@@ -615,7 +615,7 @@ def test_poisson_fem(ctx_factory):
 
         lp.auto_test_vs_ref(
                 add_types(ref_knl), ctx, add_types(knl),
-                parameters=dict(n=5, nels=15, nbf=5, sdim=2, nqp=7))
+                parameters={"n": 5, "nels": 15, "nbf": 5, "sdim": 2, "nqp": 7})
 
 
 def test_domain_tree_nesting():
diff --git a/test/test_dg.py b/test/test_dg.py
index 04104620845820b3d46c83060532e8327a835282..e19507260fc52df172e042bf5e6b254aeee04228 100644
--- a/test/test_dg.py
+++ b/test/test_dg.py
@@ -79,22 +79,22 @@ def test_dg_volume(ctx_factory):
     seq_knl = knl
 
     def variant_basic(knl):
-        knl = lp.tag_inames(knl, dict(k="g.0", n="l.0"))
+        knl = lp.tag_inames(knl, {"k": "g.0", "n": "l.0"})
         return knl
 
     def variant_more_per_work_group(knl):
-        knl = lp.tag_inames(knl, dict(n="l.0"))
+        knl = lp.tag_inames(knl, {"n": "l.0"})
         knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1")
         return knl
 
     def variant_image_d(knl):
-        knl = lp.tag_inames(knl, dict(n="l.0"))
+        knl = lp.tag_inames(knl, {"n": "l.0"})
         knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1")
         knl = lp.change_arg_to_image(knl, "DrDsDt")
         return knl
 
     def variant_prefetch_d(knl):
-        knl = lp.tag_inames(knl, dict(n="l.0"))
+        knl = lp.tag_inames(knl, {"n": "l.0"})
         knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1")
         knl = lp.add_prefetch(knl, "DrDsDt[:,:]",
                 fetch_outer_inames="k_outer",
@@ -102,7 +102,7 @@ def test_dg_volume(ctx_factory):
         return knl
 
     def variant_prefetch_fields(knl):
-        knl = lp.tag_inames(knl, dict(n="l.0"))
+        knl = lp.tag_inames(knl, {"n": "l.0"})
         knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1")
         for name in ["u", "v", "w", "p"]:
             knl = lp.add_prefetch(knl, "%s[k,:]" % name, ["k_inner"],
@@ -111,14 +111,14 @@ def test_dg_volume(ctx_factory):
         return knl
 
     def variant_k_ilp(knl):
-        knl = lp.tag_inames(knl, dict(n="l.0"))
+        knl = lp.tag_inames(knl, {"n": "l.0"})
 
         knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="ilp")
-        knl = lp.tag_inames(knl, dict(m="unr"))
+        knl = lp.tag_inames(knl, {"m": "unr"})
         return knl
 
     def variant_simple_padding(knl):
-        knl = lp.tag_inames(knl, dict(n="l.0"))
+        knl = lp.tag_inames(knl, {"n": "l.0"})
 
         knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1")
 
@@ -130,12 +130,12 @@ def test_dg_volume(ctx_factory):
         for name in arg_names:
             knl = lp.add_padding(knl, name, axis=0, align_bytes=32)
 
-        knl = lp.tag_inames(knl, dict(m="unr"))
+        knl = lp.tag_inames(knl, {"m": "unr"})
 
         return knl
 
     def variant_fancy_padding(knl):
-        knl = lp.tag_inames(knl, dict(n="l.0"))
+        knl = lp.tag_inames(knl, {"n": "l.0"})
 
         pad_mult = lp.find_padding_multiple(knl, "u", 1, 32)
 
@@ -148,7 +148,7 @@ def test_dg_volume(ctx_factory):
 
         return knl
 
-    parameters_dict = dict(K=K)
+    parameters_dict = {"K": K}
 
     variants = [
             variant_basic,
@@ -232,7 +232,7 @@ def no_test_dg_surface(ctx_factory):
     def variant_basic(knl):
         return knl
 
-    parameters_dict = dict(K=K)
+    parameters_dict = {"K": K}
 
     for variant in [
             variant_basic,
diff --git a/test/test_domain.py b/test/test_domain.py
index f8f812bc1782ac535674568b1c056703efcd6ce4..c915498ed73a90d018bb85c29f34c903a7d79297 100644
--- a/test/test_domain.py
+++ b/test/test_domain.py
@@ -309,7 +309,7 @@ def test_equality_constraints(ctx_factory):
     # print(knl.domains[0].detect_equalities())
 
     lp.auto_test_vs_ref(seq_knl, ctx, knl,
-            parameters=dict(n=n), print_ref_code=True)
+            parameters={"n": n}, print_ref_code=True)
 
 
 def test_stride(ctx_factory):
@@ -335,7 +335,7 @@ def test_stride(ctx_factory):
     seq_knl = knl
 
     lp.auto_test_vs_ref(seq_knl, ctx, knl,
-            parameters=dict(n=n))
+            parameters={"n": n})
 
 
 def test_domain_dependency_via_existentially_quantified_variable(ctx_factory):
@@ -363,7 +363,7 @@ def test_domain_dependency_via_existentially_quantified_variable(ctx_factory):
     seq_knl = knl
 
     lp.auto_test_vs_ref(seq_knl, ctx, knl,
-            parameters=dict(n=n))
+            parameters={"n": n})
 
 
 def test_triangle_domain():
diff --git a/test/test_fortran.py b/test/test_fortran.py
index aa7c241eac3e7968d224a8f342e47e5367eba01e..7a5d73a9543d39fdf9c4838b9539d8604a66250d 100644
--- a/test/test_fortran.py
+++ b/test/test_fortran.py
@@ -176,7 +176,7 @@ def test_fill(ctx_factory):
 
     ctx = ctx_factory()
 
-    lp.auto_test_vs_ref(knl, ctx, knl, parameters=dict(n=5, a=5))
+    lp.auto_test_vs_ref(knl, ctx, knl, parameters={"n": 5, "a": 5})
 
 
 def test_fill_const(ctx_factory):
@@ -197,7 +197,7 @@ def test_fill_const(ctx_factory):
 
     ctx = ctx_factory()
 
-    lp.auto_test_vs_ref(knl, ctx, knl, parameters=dict(n=5, a=5))
+    lp.auto_test_vs_ref(knl, ctx, knl, parameters={"n": 5, "a": 5})
 
 
 def test_asterisk_in_shape(ctx_factory):
@@ -247,7 +247,7 @@ def test_assignment_to_subst(ctx_factory):
     knl = lp.assignment_to_subst(knl, "a", "i")
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 def test_assignment_to_subst_two_defs(ctx_factory):
@@ -274,7 +274,7 @@ def test_assignment_to_subst_two_defs(ctx_factory):
     knl = lp.assignment_to_subst(knl, "a")
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 def test_assignment_to_subst_indices(ctx_factory):
@@ -339,7 +339,7 @@ def test_if(ctx_factory):
     knl = lp.assignment_to_subst(knl, "a")
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 def test_tagged(ctx_factory):
@@ -427,7 +427,8 @@ def test_matmul(ctx_factory, buffer_inames):
     prog = lp.buffer_array(prog, "c", buffer_inames=buffer_inames,
             init_expression="0", store_expression="base+buffer")
 
-    lp.auto_test_vs_ref(ref_prog, ctx, prog, parameters=dict(n=128, m=128, ell=128))
+    lp.auto_test_vs_ref(ref_prog, ctx, prog,
+                        parameters={"n": 128, "m": 128, "ell": 128})
 
 
 @pytest.mark.xfail
@@ -524,7 +525,7 @@ def test_fuse_kernels(ctx_factory):
     assert len(knl["xderiv_and_yderiv"].temporary_variables) == 2
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(xyderiv, ctx, knl, parameters=dict(nelements=20, ndofs=4))
+    lp.auto_test_vs_ref(xyderiv, ctx, knl, parameters={"nelements": 20, "ndofs": 4})
 
 
 def test_parse_and_fuse_two_kernels():
@@ -610,7 +611,7 @@ def test_precompute_some_exist(ctx_factory):
     ref_knl = knl
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=128, m=128, ell=128))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 128, "m": 128, "ell": 128})
 
 
 def test_fortran_subroutines():
@@ -679,7 +680,7 @@ def test_division_in_shapes(ctx_factory):
     print(t_unit)
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(ref_t_unit, ctx, t_unit, parameters=dict(m=128))
+    lp.auto_test_vs_ref(ref_t_unit, ctx, t_unit, parameters={"m": 128})
 
 
 if __name__ == "__main__":
diff --git a/test/test_linalg.py b/test/test_linalg.py
index 99273ae9f59e5ae12e7b74087335a12e637c46cb..ebd2e96bdfdf803ec68cdf72d0118db5c30f0493 100644
--- a/test/test_linalg.py
+++ b/test/test_linalg.py
@@ -644,7 +644,7 @@ def test_fancy_matrix_mul(ctx_factory):
 
     lp.auto_test_vs_ref(seq_knl, ctx, knl,
             op_count=[2*n**3/1e9], op_label=["GFlops"],
-            parameters=dict(n=n))
+            parameters={"n": n})
 
 
 def test_small_batched_matvec(ctx_factory):
@@ -678,7 +678,7 @@ def test_small_batched_matvec(ctx_factory):
 
     lp.auto_test_vs_ref(seq_knl, ctx, knl,
             op_count=[K*2*Np**2/1e9], op_label=["GFlops"],
-            parameters=dict(K=K))
+            parameters={"K": K})
 
 
 if __name__ == "__main__":
diff --git a/test/test_loopy.py b/test/test_loopy.py
index 44281bab7bfa3f756405126af726bb5e42a1bbec..d9d1681810486e5b961d1807794419f9ab9b4966 100644
--- a/test/test_loopy.py
+++ b/test/test_loopy.py
@@ -175,7 +175,7 @@ def test_sized_and_complex_literals(ctx_factory):
                 ],
             assumptions="n>=1")
 
-    lp.auto_test_vs_ref(knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(knl, ctx, knl, parameters={"n": 5})
 
 
 def test_simple_side_effect():
@@ -202,7 +202,7 @@ def test_owed_barriers():
             target=lp.PyOpenCLTarget()
             )
 
-    knl = lp.tag_inames(knl, dict(i="l.0"))
+    knl = lp.tag_inames(knl, {"i": "l.0"})
 
     print(knl)
     print(lp.generate_code_v2(knl))
@@ -265,7 +265,7 @@ def test_ilp_write_race_detection_global():
             target=lp.PyOpenCLTarget(),
             name="loopy_kernel")
 
-    knl = lp.tag_inames(knl, dict(j="ilp"))
+    knl = lp.tag_inames(knl, {"j": "ilp"})
 
     knl = lp.preprocess_kernel(knl)
 
@@ -291,7 +291,7 @@ def test_ilp_write_race_avoidance_local():
             target=lp.PyOpenCLTarget(),
             name="loopy_kernel")
 
-    knl = lp.tag_inames(knl, dict(i="l.0", j="ilp"))
+    knl = lp.tag_inames(knl, {"i": "l.0", "j": "ilp"})
 
     knl = lp.preprocess_kernel(knl)
     assert knl["loopy_kernel"].temporary_variables["a"].shape == (16, 17)
@@ -307,7 +307,7 @@ def test_ilp_write_race_avoidance_private():
             target=lp.PyOpenCLTarget(),
             name="loopy_kernel")
 
-    knl = lp.tag_inames(knl, dict(j="ilp"))
+    knl = lp.tag_inames(knl, {"j": "ilp"})
 
     knl = lp.preprocess_kernel(knl)
     assert knl["loopy_kernel"].temporary_variables["a"].shape == (16,)
@@ -409,7 +409,7 @@ def test_unknown_arg_shape():
         target=lp.PyOpenCLTarget(),
         assumptions="m<=%d and m>=1 and n mod %d = 0" % (bsize[0], bsize[0]))
 
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32})
     print(lp.generate_code_v2(knl).device_code())
 
 # }}}
@@ -539,12 +539,12 @@ def test_dependent_domain_insn_iname_finding():
     assert "isrc_box" in prog["loopy_kernel"].insn_inames("set_strength")
 
     prog = lp.add_dtypes(prog,
-        dict(
-            source_boxes=np.int32,
-            box_source_starts=np.int32,
-            box_source_counts_nonchild=np.int32,
-            strengths=np.float64,
-            nsources=np.int32))
+        {
+            "source_boxes": np.int32,
+            "box_source_starts": np.int32,
+            "box_source_counts_nonchild": np.int32,
+            "strengths": np.float64,
+            "nsources": np.int32})
     print(lp.generate_code_v2(prog).device_code())
 
 
@@ -601,14 +601,14 @@ def test_vector_types(ctx_factory, vec_len):
     ref_knl = knl
 
     knl = lp.tag_array_axes(knl, "out", "c,vec")
-    knl = lp.tag_inames(knl, dict(j="unr"))
+    knl = lp.tag_inames(knl, {"j": "unr"})
 
     knl = lp.split_iname(knl, "i", 128, outer_tag="g.0", inner_tag="l.0")
 
     lp.auto_test_vs_ref(ref_knl, ctx, knl,
-            parameters=dict(
-                n=20000
-                ))
+            parameters={
+                "n": 20000
+                })
 
 
 def test_conditional(ctx_factory):
@@ -633,9 +633,9 @@ def test_conditional(ctx_factory):
     ref_knl = knl
 
     lp.auto_test_vs_ref(ref_knl, ctx, knl,
-            parameters=dict(
-                n=200
-                ))
+            parameters={
+                "n": 200
+                })
 
 
 def test_conditional_two_ways(ctx_factory):
@@ -677,9 +677,9 @@ def test_conditional_two_ways(ctx_factory):
     ref_knl = knl
 
     lp.auto_test_vs_ref(ref_knl, ctx, knl,
-            parameters=dict(
-                n=200
-                ))
+            parameters={
+                "n": 200
+                })
 
 
 def test_ilp_loop_bound(ctx_factory):
@@ -706,9 +706,9 @@ def test_ilp_loop_bound(ctx_factory):
     knl = lp.split_iname(knl,  "k", 4, inner_tag="ilp")
 
     lp.auto_test_vs_ref(ref_knl, ctx, knl,
-            parameters=dict(
-                n=200
-                ))
+            parameters={
+                "n": 200
+                })
 
 
 def test_arg_shape_uses_assumptions(ctx_factory):
@@ -771,7 +771,7 @@ def test_multiple_writes_to_local_temporary():
         <> temp[i, 0] = 17
         temp[i, 1] = 15
         """)
-    knl = lp.tag_inames(knl, dict(i="l.0"))
+    knl = lp.tag_inames(knl, {"i": "l.0"})
     print(lp.generate_code_v2(knl).device_code())
 
 
@@ -830,14 +830,14 @@ def test_auto_test_can_detect_problems(ctx_factory):
         a[i,i] = 25
         """)
 
-    ref_knl = lp.add_and_infer_dtypes(ref_knl, dict(a=np.float32))
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32))
+    ref_knl = lp.add_and_infer_dtypes(ref_knl, {"a": np.float32})
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32})
 
     from loopy.diagnostic import AutomaticTestFailure
     with pytest.raises(AutomaticTestFailure):
         lp.auto_test_vs_ref(
                 ref_knl, ctx, knl,
-                parameters=dict(n=123))
+                parameters={"n": 123})
 
 
 def test_auto_test_zero_warmup_rounds(ctx_factory):
@@ -849,11 +849,11 @@ def test_auto_test_zero_warmup_rounds(ctx_factory):
         a[i,j] = 25
         """)
 
-    ref_knl = lp.add_and_infer_dtypes(ref_knl, dict(a=np.float32))
+    ref_knl = lp.add_and_infer_dtypes(ref_knl, {"a": np.float32})
 
     lp.auto_test_vs_ref(
             ref_knl, ctx, ref_knl,
-            parameters=dict(n=12),
+            parameters={"n": 12},
             warmup_rounds=0)
 
 
@@ -894,7 +894,7 @@ def test_atomic(ctx_factory, dtype):
     ref_knl = knl
     knl = lp.split_iname(knl, "i", 512)
     knl = lp.split_iname(knl, "i_inner", 128, outer_tag="unr", inner_tag="g.0")
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=10000))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 10000})
 
 
 @pytest.mark.parametrize("dtype", [np.int32, np.int64, np.float32, np.float64])
@@ -1001,7 +1001,7 @@ def test_literal_local_barrier(ctx_factory):
 
     ref_knl = knl
 
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 def test_local_barrier_mem_kind():
@@ -1056,7 +1056,7 @@ def test_kernel_splitting(ctx_factory):
     print(cgr.device_code())
     print(cgr.host_code())
 
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 def test_kernel_splitting_with_loop(ctx_factory):
@@ -1090,7 +1090,7 @@ def test_kernel_splitting_with_loop(ctx_factory):
     print(cgr.device_code())
     print(cgr.host_code())
 
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 def save_and_reload_temporaries_test(queue, prog, out_expect, debug=False):
@@ -1126,7 +1126,7 @@ def test_save_of_private_scalar(ctx_factory, hw_loop, debug=False):
         """, seq_dependencies=True)
 
     if hw_loop:
-        prog = lp.tag_inames(prog, dict(i="g.0"))
+        prog = lp.tag_inames(prog, {"i": "g.0"})
 
     save_and_reload_temporaries_test(queue, prog, np.arange(8), debug)
 
@@ -1167,7 +1167,7 @@ def test_save_of_private_array_in_hw_loop(ctx_factory, debug=False):
         end
         """, seq_dependencies=True)
 
-    knl = lp.tag_inames(knl, dict(i="g.0"))
+    knl = lp.tag_inames(knl, {"i": "g.0"})
     knl = lp.set_temporary_address_space(knl, "t", "private")
 
     save_and_reload_temporaries_test(
@@ -1217,7 +1217,7 @@ def test_save_of_private_multidim_array_in_hw_loop(ctx_factory, debug=False):
         """, seq_dependencies=True)
 
     knl = lp.set_temporary_address_space(knl, "t", "private")
-    knl = lp.tag_inames(knl, dict(i="g.0"))
+    knl = lp.tag_inames(knl, {"i": "g.0"})
 
     result = np.array([np.vstack(8 * (np.arange(8),)) for i in range(8)])
     save_and_reload_temporaries_test(queue, knl, result, debug)
@@ -1250,7 +1250,7 @@ def test_save_of_multiple_private_temporaries(ctx_factory, hw_loop, debug=False)
 
     knl = lp.set_temporary_address_space(knl, "t_arr", "private")
     if hw_loop:
-        knl = lp.tag_inames(knl, dict(i="g.0"))
+        knl = lp.tag_inames(knl, {"i": "g.0"})
 
     result = np.array([1, 10, 10, 10, 10, 10, 10, 10, 10, 9])
 
@@ -1273,7 +1273,7 @@ def test_save_of_local_array(ctx_factory, debug=False):
         """, seq_dependencies=True)
 
     knl = lp.set_temporary_address_space(knl, "t", "local")
-    knl = lp.tag_inames(knl, dict(i="g.0", j="l.0"))
+    knl = lp.tag_inames(knl, {"i": "g.0", "j": "l.0"})
 
     save_and_reload_temporaries_test(queue, knl, np.arange(8), debug)
 
@@ -1295,7 +1295,7 @@ def test_save_of_local_array_with_explicit_local_barrier(ctx_factory, debug=Fals
         """, seq_dependencies=True)
 
     knl = lp.set_temporary_address_space(knl, "t", "local")
-    knl = lp.tag_inames(knl, dict(i="g.0", j="l.0"))
+    knl = lp.tag_inames(knl, {"i": "g.0", "j": "l.0"})
 
     save_and_reload_temporaries_test(queue, knl, np.arange(8), debug)
 
@@ -1316,7 +1316,7 @@ def test_save_local_multidim_array(ctx_factory, debug=False):
             """, seq_dependencies=True)
 
     knl = lp.set_temporary_address_space(knl, "t_local", "local")
-    knl = lp.tag_inames(knl, dict(j="l.0", i="g.0"))
+    knl = lp.tag_inames(knl, {"j": "l.0", "i": "g.0"})
 
     save_and_reload_temporaries_test(queue, knl, 1, debug)
 
@@ -1336,7 +1336,7 @@ def test_save_with_base_storage(ctx_factory, debug=False):
             "...",
             seq_dependencies=True)
 
-    knl = lp.tag_inames(knl, dict(i="l.0"))
+    knl = lp.tag_inames(knl, {"i": "l.0"})
     knl = lp.set_temporary_address_space(knl, "a", "local")
     knl = lp.set_temporary_address_space(knl, "b", "local")
 
@@ -1359,7 +1359,7 @@ def test_save_ambiguous_storage_requirements():
             """,
             seq_dependencies=True)
 
-    knl = lp.tag_inames(knl, dict(i="g.0", j="l.0"))
+    knl = lp.tag_inames(knl, {"i": "g.0", "j": "l.0"})
     knl = lp.duplicate_inames(knl, "j", within="writes:out", tags={"j": "l.0"})
     knl = lp.set_temporary_address_space(knl, "a", "local")
 
@@ -1382,7 +1382,7 @@ def test_save_across_inames_with_same_tag(ctx_factory, debug=False):
             "...",
             seq_dependencies=True)
 
-    knl = lp.tag_inames(knl, dict(i="l.0"))
+    knl = lp.tag_inames(knl, {"i": "l.0"})
     knl = lp.duplicate_inames(knl, "i", within="reads:a", tags={"i": "l.0"})
 
     save_and_reload_temporaries_test(queue, knl, np.arange(10), debug)
@@ -1453,7 +1453,7 @@ def test_global_temporary(ctx_factory):
     print(cgr.device_code())
     # print(cgr.host_code())
 
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 def test_assign_to_linear_subscript(ctx_factory):
@@ -1644,7 +1644,7 @@ def test_sequential_dependencies(ctx_factory):
 
     print(prog["loopy_kernel"].stringify(with_dependencies=True))
 
-    lp.auto_test_vs_ref(prog, ctx, prog, parameters=dict(n=5))
+    lp.auto_test_vs_ref(prog, ctx, prog, parameters={"n": 5})
 
 
 def test_nop(ctx_factory):
@@ -1666,7 +1666,7 @@ def test_nop(ctx_factory):
     knl = lp.fix_parameters(knl, n=15)
     knl = lp.add_and_infer_dtypes(knl, {"z": np.float64})
 
-    lp.auto_test_vs_ref(knl, ctx, knl, parameters=dict(ntrips=5))
+    lp.auto_test_vs_ref(knl, ctx, knl, parameters={"ntrips": 5})
 
 
 def test_global_barrier(ctx_factory):
@@ -1708,7 +1708,7 @@ def test_global_barrier(ctx_factory):
 
     print(knl)
 
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(ntrips=5, n=10))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"ntrips": 5, "n": 10})
 
 
 def test_missing_global_barrier():
@@ -2247,7 +2247,7 @@ def test_barrier_insertion_near_top_of_loop():
         """,
         seq_dependencies=True)
 
-    prog = lp.tag_inames(prog, dict(i="l.0"))
+    prog = lp.tag_inames(prog, {"i": "l.0"})
     prog = lp.set_temporary_address_space(prog, "a", "local")
     prog = lp.set_temporary_address_space(prog, "b", "local")
     prog = lp.preprocess_kernel(prog)
@@ -2273,7 +2273,7 @@ def test_barrier_insertion_near_bottom_of_loop():
         end
         """,
         seq_dependencies=True)
-    prog = lp.tag_inames(prog, dict(i="l.0"))
+    prog = lp.tag_inames(prog, {"i": "l.0"})
     prog = lp.set_temporary_address_space(prog, "a", "local")
     prog = lp.set_temporary_address_space(prog, "b", "local")
     prog = lp.preprocess_kernel(prog)
@@ -2449,7 +2449,7 @@ def test_inames_conditional_generation(ctx_factory):
             "...",
             seq_dependencies=True)
 
-    knl = lp.tag_inames(knl, dict(i="g.0"))
+    knl = lp.tag_inames(knl, {"i": "g.0"})
 
     with cl.CommandQueue(ctx) as queue:
         knl(queue)
@@ -2465,7 +2465,7 @@ def test_fixed_parameters(ctx_factory):
             <>tmp[i] = i  {id=init}
             tmp[0] = 0  {dep=init}
             """,
-            fixed_parameters=dict(n=1))
+            fixed_parameters={"n": 1})
 
     knl(queue)
 
@@ -2485,7 +2485,7 @@ def test_execution_backend_can_cache_dtypes(ctx_factory):
     queue = cl.CommandQueue(ctx)
 
     knl = lp.make_kernel("{[i]: 0 <= i < 10}", "<>tmp[i] = i")
-    knl = lp.add_dtypes(knl, dict(tmp=int))
+    knl = lp.add_dtypes(knl, {"tmp": int})
 
     knl(queue)
 
@@ -2720,7 +2720,7 @@ def test_dump_binary(ctx_factory):
     ref_knl = knl
 
     lp.auto_test_vs_ref(
-            ref_knl, ctx, knl, parameters=dict(n=5),
+            ref_knl, ctx, knl, parameters={"n": 5},
             dump_binary=True)
 
 
@@ -2964,7 +2964,7 @@ def test_split_iname_within(ctx_factory):
         x[i, j] = 3 {id=a}
         y[i, j] = 2 * y[i, j] {id=b}
         """,
-        options=dict(write_code=True))
+        options={"write_code": True})
 
     ref_knl = knl
 
@@ -2975,7 +2975,7 @@ def test_split_iname_within(ctx_factory):
                          outer_tag="g.0", inner_tag="l.0",
                          within="id:b")
 
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=5))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5})
 
 
 @pytest.mark.parametrize("base_type,exp_type", [
@@ -3272,7 +3272,7 @@ def test_sep_array_ordering(ctx_factory):
         x[k, i] = k
         """,
         [lp.GlobalArg("x", shape=("noutputs", "m"), dim_tags="sep,C"), ...],
-        fixed_parameters=dict(noutputs=n),
+        fixed_parameters={"noutputs": n},
         )
     knl = lp.tag_inames(knl, "k:unr")
 
@@ -3677,8 +3677,8 @@ def test_no_unnecessary_lbarrier(ctx_factory):
         """,
         assumptions="n>=0")
 
-    t_unit = lp.add_dtypes(t_unit, dict(ai=np.float32))
-    t_unit = lp.tag_inames(t_unit, dict(i_inner="l.0", i_outer="g.0"))
+    t_unit = lp.add_dtypes(t_unit, {"ai": np.float32})
+    t_unit = lp.tag_inames(t_unit, {"i_inner": "l.0", "i_outer": "g.0"})
     t_unit = lp.set_temporary_address_space(t_unit, "s_a", "local")
     t_unit = lp.prioritize_loops(t_unit, "i_outer,i_inner")
 
diff --git a/test/test_nbody.py b/test/test_nbody.py
index e258d801e220f836b2062dd87fc23d9a20dda9a6..02dcb17438b7fb960cde197e473ebbfbd9e66972 100644
--- a/test/test_nbody.py
+++ b/test/test_nbody.py
@@ -81,7 +81,7 @@ def test_nbody(ctx_factory):
         knl = lp.add_prefetch(knl, "x[j,k]", ["j_inner", "k"],
                 ["x_fetch_j", "x_fetch_k"],
                 fetch_outer_inames="i_outer, j_outer", default_tag=None)
-        knl = lp.tag_inames(knl, dict(x_fetch_k="unr", x_fetch_j="l.0"))
+        knl = lp.tag_inames(knl, {"x_fetch_k": "unr", "x_fetch_j": "l.0"})
         knl = lp.add_prefetch(knl, "x[i,k]", ["k"], default_tag=None)
         knl = lp.prioritize_loops(knl, ["j_outer", "j_inner"])
         return knl
diff --git a/test/test_numa_diff.py b/test/test_numa_diff.py
index 55ff270a29d6178af0ea01118f9e842f9a041f8b..92020b73abca57c74840050a667b29d89ca27c68 100644
--- a/test/test_numa_diff.py
+++ b/test/test_numa_diff.py
@@ -84,7 +84,7 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level):  # noqa
 
     hsv = lp.fix_parameters(hsv, Nq=Nq)
     hsv = lp.prioritize_loops(hsv, "e,k,j,i")
-    hsv = lp.tag_inames(hsv, dict(e="g.0", j="l.1", i="l.0"))
+    hsv = lp.tag_inames(hsv, {"e": "g.0", "j": "l.1", "i": "l.0"})
     hsv = lp.assume(hsv, "elements >= 1")
 
     hsv = fix_euler_parameters(hsv, p_p0=1, p_Gamma=1.4, p_R=1)
@@ -168,7 +168,7 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level):  # noqa
             hsv = lp.rename_iname(hsv, "n", n_iname, within="id:"+reader.id,
                   existing_ok=True)
 
-    hsv = lp.tag_inames(hsv, dict(ii="l.0", jj="l.1"))
+    hsv = lp.tag_inames(hsv, {"ii": "l.0", "jj": "l.1"})
     for iname in flux_ilp_inames:
         hsv = lp.tag_inames(hsv, {iname: "ilp"})
 
@@ -193,9 +193,9 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level):  # noqa
 
     if opt_level == 4:
         tap_hsv = hsv
-        tap_hsv = lp.tag_inames(tap_hsv, dict(
-              Q_dim_field_inner="unr",
-              Q_dim_field_outer="unr"))
+        tap_hsv = lp.tag_inames(tap_hsv, {
+              "Q_dim_field_inner": "unr",
+              "Q_dim_field_outer": "unr"})
 
     hsv = lp.buffer_array(hsv, "rhsQ", ilp_inames,
           fetch_bounding_box=True, default_tag="for",
@@ -203,11 +203,11 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level):  # noqa
 
     if opt_level == 5:
         tap_hsv = hsv
-        tap_hsv = lp.tag_inames(tap_hsv, dict(
-              rhsQ_init_field_inner="unr", rhsQ_store_field_inner="unr",
-              rhsQ_init_field_outer="unr", rhsQ_store_field_outer="unr",
-              Q_dim_field_inner="unr",
-              Q_dim_field_outer="unr"))
+        tap_hsv = lp.tag_inames(tap_hsv, {
+              "rhsQ_init_field_inner": "unr", "rhsQ_store_field_inner": "unr",
+              "rhsQ_init_field_outer": "unr", "rhsQ_store_field_outer": "unr",
+              "Q_dim_field_inner": "unr",
+              "Q_dim_field_outer": "unr"})
 
     # buffer axes need to be vectorized in order for this to work
     hsv = lp.tag_array_axes(hsv, "rhsQ_buf", "c?,vec,c")
@@ -219,17 +219,17 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level):  # noqa
 
     if opt_level == 6:
         tap_hsv = hsv
-        tap_hsv = lp.tag_inames(tap_hsv, dict(
-              rhsQ_init_field_inner="unr", rhsQ_store_field_inner="unr",
-              rhsQ_init_field_outer="unr", rhsQ_store_field_outer="unr",
-              Q_dim_field_inner="unr",
-              Q_dim_field_outer="unr"))
-
-    hsv = lp.tag_inames(hsv, dict(
-          rhsQ_init_field_inner="vec", rhsQ_store_field_inner="vec",
-          rhsQ_init_field_outer="unr", rhsQ_store_field_outer="unr",
-          Q_dim_field_inner="vec",
-          Q_dim_field_outer="unr"))
+        tap_hsv = lp.tag_inames(tap_hsv, {
+              "rhsQ_init_field_inner": "unr", "rhsQ_store_field_inner": "unr",
+              "rhsQ_init_field_outer": "unr", "rhsQ_store_field_outer": "unr",
+              "Q_dim_field_inner": "unr",
+              "Q_dim_field_outer": "unr"})
+
+    hsv = lp.tag_inames(hsv, {
+          "rhsQ_init_field_inner": "vec", "rhsQ_store_field_inner": "vec",
+          "rhsQ_init_field_outer": "unr", "rhsQ_store_field_outer": "unr",
+          "Q_dim_field_inner": "vec",
+          "Q_dim_field_outer": "unr"})
 
     if opt_level == 7:
         tap_hsv = hsv
@@ -266,7 +266,7 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level):  # noqa
     # add a simple transformation for it
     # hsv = hsv.copy(name="horizontalStrongVolumeKernel")
 
-    results = lp.auto_test_vs_ref(ref_hsv, ctx, hsv, parameters=dict(elements=300),
+    results = lp.auto_test_vs_ref(ref_hsv, ctx, hsv, parameters={"elements": 300},
             quiet=True)
 
     elapsed = results["elapsed_wall"]
diff --git a/test/test_reduction.py b/test/test_reduction.py
index dcf92b7a8d6be4cf055f83b08b1005f927d62f81..125d247d9b522577051f93755ed15ccdb0ff0c2e 100644
--- a/test/test_reduction.py
+++ b/test/test_reduction.py
@@ -408,8 +408,8 @@ def test_parallel_multi_output_reduction(ctx_factory):
                 """
                 max_val, max_indices = argmax(i, abs(a[i]), i)
                 """)
-    knl = lp.tag_inames(knl, dict(i="l.0"))
-    knl = lp.add_dtypes(knl, dict(a=np.float64))
+    knl = lp.tag_inames(knl, {"i": "l.0"})
+    knl = lp.add_dtypes(knl, {"a": np.float64})
 
     ctx = ctx_factory()
 
diff --git a/test/test_scan.py b/test/test_scan.py
index abba7ad0c12f8ce1118f5e7343754b98e639c746..47c2e04b4b52bec3d2b2662c62aa032caa1d9a27 100644
--- a/test/test_scan.py
+++ b/test/test_scan.py
@@ -138,7 +138,7 @@ def test_force_outer_iname_for_scan():
         "[n] -> {[i,j,k]: 0<=k<n and 0<=i<=k and 0<=j<=i}",
         "out[i] = product(j, a[j]) {inames=i:k}")
 
-    knl = lp.add_dtypes(knl, dict(a=np.float32))
+    knl = lp.add_dtypes(knl, {"a": np.float32})
 
     # TODO: Maybe this deserves to work?
     with pytest.raises(lp.diagnostic.ReductionIsNotTriangularError):
@@ -185,7 +185,7 @@ def test_nested_scan(ctx_factory, i_tag, j_tag):
         """)
 
     knl = lp.fix_parameters(knl, n=10)
-    knl = lp.tag_inames(knl, dict(i=i_tag, j=j_tag))
+    knl = lp.tag_inames(knl, {"i": i_tag, "j": j_tag})
 
     knl = lp.realize_reduction(knl, force_scan=True)
 
@@ -222,10 +222,10 @@ def test_local_parallel_scan(ctx_factory, n):
         )
 
     knl = lp.fix_parameters(knl, n=n)
-    knl = lp.tag_inames(knl, dict(i="l.0"))
+    knl = lp.tag_inames(knl, {"i": "l.0"})
     knl = lp.realize_reduction(knl, force_scan=True)
 
-    knl = lp.add_dtypes(knl, dict(a=int))
+    knl = lp.add_dtypes(knl, {"a": int})
 
     _evt, (a,) = knl(queue, a=np.arange(n))
     assert (a == np.cumsum(np.arange(n)**2)).all()
@@ -244,10 +244,10 @@ def test_local_parallel_scan_with_nonzero_lower_bounds(ctx_factory):
         )
 
     knl = lp.fix_parameters(knl, n=16)
-    knl = lp.tag_inames(knl, dict(i="l.0"))
+    knl = lp.tag_inames(knl, {"i": "l.0"})
     knl = lp.realize_reduction(knl, force_scan=True)
 
-    knl = lp.add_dtypes(knl, dict(a=int))
+    knl = lp.add_dtypes(knl, {"a": int})
     _evt, (out,) = knl(queue, a=np.arange(1, 17))
 
     assert (out == np.cumsum(np.arange(1, 17)**2)).all()
@@ -276,7 +276,7 @@ def test_scan_with_outer_parallel_iname(ctx_factory, sweep_iname_tag):
         "out[k,i] = k + sum(j, j**2)"
         )
 
-    knl = lp.tag_inames(knl, dict(k="l.0", i=sweep_iname_tag))
+    knl = lp.tag_inames(knl, {"k": "l.0", "i": sweep_iname_tag})
     n = 10
     knl = lp.fix_parameters(knl, n=n)
     knl = lp.realize_reduction(knl, force_scan=True)
@@ -300,7 +300,7 @@ def test_scan_data_types(ctx_factory, dtype):
             assumptions="n>=1")
 
     a = np.random.randn(20).astype(dtype)
-    knl = lp.add_dtypes(knl, dict(a=dtype))
+    knl = lp.add_dtypes(knl, {"a": dtype})
     knl = lp.realize_reduction(knl, force_scan=True)
     _evt, (res,) = knl(queue, a=a)
 
@@ -323,7 +323,7 @@ def test_scan_library(ctx_factory, op_name, np_op):
             assumptions="n>=1")
 
     a = np.random.randn(20)
-    knl = lp.add_dtypes(knl, dict(a=np.float64))
+    knl = lp.add_dtypes(knl, {"a": np.float64})
     knl = lp.realize_reduction(knl, force_scan=True)
     _evt, (res,) = knl(queue, a=a)
 
@@ -351,7 +351,7 @@ def test_argmax(ctx_factory, i_tag):
             max_vals[i], max_indices[i] = argmax(j, abs(a[j]), j)
             """)
 
-    knl = lp.tag_inames(knl, dict(i=i_tag))
+    knl = lp.tag_inames(knl, {"i": i_tag})
     knl = lp.add_and_infer_dtypes(knl, {"a": np.float32})
     knl = lp.realize_reduction(knl, force_scan=True)
 
@@ -414,7 +414,7 @@ def test_segmented_scan(ctx_factory, n, segment_boundaries_indices, iname_tag):
         ])
 
     knl = lp.fix_parameters(knl, n=n)
-    knl = lp.tag_inames(knl, dict(i=iname_tag))
+    knl = lp.tag_inames(knl, {"i": iname_tag})
     knl = lp.realize_reduction(knl, force_scan=True)
 
     (_evt, (out,)) = knl(queue, arr=arr, segflag=segment_boundaries)
diff --git a/test/test_sem_reagan.py b/test/test_sem_reagan.py
index c83ff6b8b6cedcde886da02542877fe5b21dd7bb..7969795bf7de4e4605e1f4cd210fe3de6b3de061 100644
--- a/test/test_sem_reagan.py
+++ b/test/test_sem_reagan.py
@@ -78,7 +78,7 @@ def test_tim2d(ctx_factory):
     seq_knl = knl
 
     def variant_orig(knl):
-        knl = lp.tag_inames(knl, dict(i="l.0", j="l.1", e="g.0"))
+        knl = lp.tag_inames(knl, {"i": "l.0", "j": "l.1", "e": "g.0"})
 
         knl = lp.add_prefetch(knl, "D[:,:]", fetch_outer_inames="e",
                 default_tag="l.auto")
@@ -94,8 +94,8 @@ def test_tim2d(ctx_factory):
         knl = lp.add_prefetch(knl, "G$x[:,e,:,:]", default_tag="l.auto")
         knl = lp.add_prefetch(knl, "G$y[:,e,:,:]", default_tag="l.auto")
 
-        knl = lp.tag_inames(knl, dict(o="unr"))
-        knl = lp.tag_inames(knl, dict(m="unr"))
+        knl = lp.tag_inames(knl, {"o": "unr"})
+        knl = lp.tag_inames(knl, {"m": "unr"})
 
         knl = lp.set_instruction_priority(knl, "id:D_fetch", 5)
         print(knl)
diff --git a/test/test_statistics.py b/test/test_statistics.py
index e22d3c16b83aa38b4d9276af6b03343e0a5bfc5f..afb657ea1dc3777a175bf22f6a0353c7f83b4930 100644
--- a/test/test_statistics.py
+++ b/test/test_statistics.py
@@ -52,8 +52,8 @@ def test_op_counter_basic():
             name="basic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
-                                  dict(a=np.float32, b=np.float32,
-                                       g=np.float64, h=np.float64))
+                                  {"a": np.float32, "b": np.float32,
+                                       "g": np.float64, "h": np.float64})
     op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True,
                            count_within_subscripts=True)
     n_workgroups = 1
@@ -89,7 +89,7 @@ def test_op_counter_reduction():
             ],
             name="matmul_serial", assumptions="n,m,ell >= 1")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32})
     op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True)
     n_workgroups = 1
     group_size = 1
@@ -125,7 +125,7 @@ def test_op_counter_logic():
             ],
             name="logic", assumptions="n,m,ell >= 1")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(g=np.float32, h=np.float64))
+    knl = lp.add_and_infer_dtypes(knl, {"g": np.float32, "h": np.float64})
     op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True)
     n_workgroups = 1
     group_size = 1
@@ -163,8 +163,8 @@ def test_op_counter_special_ops():
             name="special_ops", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
-                                  dict(a=np.float32, b=np.float32,
-                                       g=np.float64, h=np.float64))
+                                  {"a": np.float32, "b": np.float32,
+                                       "g": np.float64, "h": np.float64})
     op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True,
                            count_within_subscripts=True)
     n_workgroups = 1
@@ -211,9 +211,9 @@ def test_op_counter_bitwise():
             name="bitwise", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(
-            knl, dict(
-                a=np.int32, b=np.int32,
-                g=np.int64, h=np.int64))
+            knl, {
+                "a": np.int32, "b": np.int32,
+                "g": np.int64, "h": np.int64})
 
     op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True,
                            count_within_subscripts=False)
@@ -262,7 +262,7 @@ def test_op_counter_triangular_domain():
             name="bitwise", assumptions="n,m >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
-            dict(b=np.float64))
+            {"b": np.float64})
 
     expect_fallback = False
     import islpy as isl
@@ -278,7 +278,7 @@ def test_op_counter_triangular_domain():
                     subgroup_size=SGS,
                     count_redundant_work=True
                     )[lp.Op(np.float64, "mul", CG.SUBGROUP, "bitwise")]
-    value_dict = dict(m=13, n=200)
+    value_dict = {"m": 13, "n": 200}
     flops = op_map.eval_with_dict(value_dict)
 
     n_workgroups = 1
@@ -305,7 +305,7 @@ def test_mem_access_counter_basic():
             name="basic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
-                    dict(a=np.float32, b=np.float32, g=np.float64, h=np.float64))
+            {"a": np.float32, "b": np.float32, "g": np.float64, "h": np.float64})
 
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True,
                                     subgroup_size=SGS)
@@ -376,7 +376,7 @@ def test_mem_access_counter_reduction():
             ],
             name="matmul", assumptions="n,m,ell >= 1")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32})
 
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True,
                                     subgroup_size=SGS)
@@ -437,7 +437,7 @@ def test_mem_access_counter_logic():
             ],
             name="logic", assumptions="n,m,ell >= 1")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(g=np.float32, h=np.float64))
+    knl = lp.add_and_infer_dtypes(knl, {"g": np.float32, "h": np.float64})
 
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True,
                                     subgroup_size=SGS)
@@ -481,8 +481,8 @@ def test_mem_access_counter_special_ops():
             ],
             name="special_ops", assumptions="n,m,ell >= 1")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32,
-                                            g=np.float64, h=np.float64))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32,
+                                            "g": np.float64, "h": np.float64})
 
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True,
                                     subgroup_size=SGS)
@@ -563,9 +563,9 @@ def test_mem_access_counter_bitwise():
             name="bitwise", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(
-            knl, dict(
-                a=np.int32, b=np.int32,
-                g=np.int32, h=np.int32))
+            knl, {
+                "a": np.int32, "b": np.int32,
+                "g": np.int32, "h": np.int32})
 
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True,
                                     subgroup_size=SGS)
@@ -635,9 +635,9 @@ def test_mem_access_counter_mixed():
             ],
             name="mixed", assumptions="n,m,ell >= 1")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(
-                a=np.float32, b=np.float32, g=np.float64, h=np.float64,
-                x=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {
+                "a": np.float32, "b": np.float32, "g": np.float64, "h": np.float64,
+                "x": np.float32})
 
     group_size_0 = 65
 
@@ -750,8 +750,8 @@ def test_mem_access_counter_nonconsec():
             """
             ],
             name="non_consec", assumptions="n,m,ell >= 1")
-    knl = lp.add_and_infer_dtypes(knl, dict(
-                a=np.float32, b=np.float32, g=np.float64, h=np.float64))
+    knl = lp.add_and_infer_dtypes(knl, {
+                "a": np.float32, "b": np.float32, "g": np.float64, "h": np.float64})
     lsize0 = 16
     knl = lp.split_iname(knl, "i", lsize0)
     knl = lp.tag_inames(knl, {"i_inner": "l.0", "i_outer": "g.0"})
@@ -871,8 +871,8 @@ def test_mem_access_counter_consec():
             """
             ],
             name="consec", assumptions="n,m,ell >= 1")
-    knl = lp.add_and_infer_dtypes(knl, dict(
-                a=np.float32, b=np.float32, g=np.float64, h=np.float64))
+    knl = lp.add_and_infer_dtypes(knl, {
+                "a": np.float32, "b": np.float32, "g": np.float64, "h": np.float64})
     knl = lp.tag_inames(knl, {"k": "l.0", "i": "g.0", "j": "g.1"})
 
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True,
@@ -1000,8 +1000,8 @@ def test_barrier_counter_nobarriers():
             ],
             name="basic", assumptions="n,m,ell >= 1")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32,
-                                            g=np.float64, h=np.float64))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32,
+                                            "g": np.float64, "h": np.float64})
     sync_map = lp.get_synchronization_map(knl)
     n = 512
     m = 256
@@ -1025,7 +1025,7 @@ def test_barrier_counter_barriers():
             ],
             name="weird2",
             )
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.int32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.int32})
     knl = lp.split_iname(knl, "k", 128, inner_tag="l.0")
     sync_map = lp.get_synchronization_map(knl)
     print(sync_map)
@@ -1060,7 +1060,7 @@ def test_all_counters_parallel_matmul():
                 "c[i, j] = sum(k, a[i, k]*b[k, j])"
             ],
             name="matmul", assumptions="n,m,ell >= 1")
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32})
     knl = lp.split_iname(knl, "i", bsize, outer_tag="g.0", inner_tag="l.1")
     knl = lp.split_iname(knl, "j", bsize, outer_tag="g.1", inner_tag="l.0")
     knl = lp.split_iname(knl, "k", bsize)
@@ -1189,7 +1189,7 @@ def test_floor_div_coefficient_collector():
         name="local",
         lang_version=(2018, 2))
 
-    knl = lp.add_and_infer_dtypes(knl, dict(out0=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"out0": np.float32})
     knl = lp.tag_inames(knl, "i_outer:g.1,i_inner:l.1,j_outer:g.0,j_inner:l.0")
 
     n = 512
@@ -1216,7 +1216,7 @@ def test_mem_access_tagged_variables():
                 "c$mmresult[i, j] = sum(k, a$mmaload[i, k]*b$mmbload[k, j])"
             ],
             name="matmul", assumptions="n,m,ell >= 1")
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32})
     knl = lp.split_iname(knl, "i", bsize, outer_tag="g.0", inner_tag="l.1")
     knl = lp.split_iname(knl, "j", bsize, outer_tag="g.1", inner_tag="l.0")
     knl = lp.split_iname(knl, "k", bsize)
@@ -1280,7 +1280,7 @@ def test_gather_access_footprint():
                 "c[i, j] = sum(k, a[i, k]*b[k, j]) + a[i,j]"
             ],
             name="matmul", assumptions="n >= 1")
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32})
 
     from loopy.statistics import count, gather_access_footprints
     fp = gather_access_footprints(knl)
@@ -1294,7 +1294,7 @@ def test_gather_access_footprint_2():
             "{[i]: 0<=i<n}",
             "c[2*i] = a[i]",
             name="matmul", assumptions="n >= 1")
-    knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"a": np.float32})
 
     from loopy.statistics import count, gather_access_footprints
     fp = gather_access_footprints(knl)
@@ -1318,7 +1318,7 @@ def test_summations_and_filters():
             name="basic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
-                    dict(a=np.float32, b=np.float32, g=np.float64, h=np.float64))
+            {"a": np.float32, "b": np.float32, "g": np.float64, "h": np.float64})
 
     n = 512
     m = 256
@@ -1407,14 +1407,14 @@ def test_summations_and_filters():
 
 
 def test_strided_footprint():
-    param_dict = dict(n=2**20)
+    param_dict = {"n": 2**20}
     knl = lp.make_kernel(
         "[n] -> {[i]: 0<=i<n}",
         [
             "z[i] = x[3*i]"
         ], name="s3")
 
-    knl = lp.add_and_infer_dtypes(knl, dict(x=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"x": np.float32})
 
     unr = 4
     bx = 256
diff --git a/test/test_target.py b/test/test_target.py
index 5e634f53af4a51853764a6e8ee36aaaf758a19ee..a3c4356b0cede1b6e82e76836191f3ba26b709d9 100644
--- a/test/test_target.py
+++ b/test/test_target.py
@@ -405,7 +405,7 @@ def test_nan_support(ctx_factory, target):
          lp.Assignment(parse("g"), NaN(np.complex64)),
          lp.Assignment(parse("h"), NaN(np.complex128)),
          ],
-        [lp.GlobalArg("a", is_input=False, shape=tuple()), ...],
+        [lp.GlobalArg("a", is_input=False, shape=()), ...],
         seq_dependencies=True, target=target())
 
     knl = lp.set_options(knl, return_dict=True)
diff --git a/test/test_transform.py b/test/test_transform.py
index d7c699d5b164d94beebcb1f7f51f94cc58de4078..3e3aabf146a724cf48265b77372f25c8f3496c6c 100644
--- a/test/test_transform.py
+++ b/test/test_transform.py
@@ -111,14 +111,14 @@ def test_collect_common_factors(ctx_factory):
             out[i] = out_tmp {dep=out_up1:out_up2}
             """)
     knl = lp.add_and_infer_dtypes(knl,
-            dict(a=np.float32, alpha=np.float32, b1=np.float32, b2=np.float32))
+            {"a": np.float32, "alpha": np.float32, "b1": np.float32, "b2": np.float32})
 
     ref_knl = knl
 
     knl = lp.split_iname(knl, "i", 256, outer_tag="g.0", inner_tag="l.0")
     knl = lp.collect_common_factors_on_increment(knl, "out_tmp")
 
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=13))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 13})
 
 
 def test_to_batched(ctx_factory):
@@ -128,18 +128,18 @@ def test_to_batched(ctx_factory):
     knl = lp.make_kernel(
          """ { [i,j]: 0<=i,j<n } """,
          """ out[i] = sum(j, a[i,j]*x[j])""")
-    knl = lp.add_and_infer_dtypes(knl, dict(out=np.float32,
-                                            x=np.float32,
-                                            a=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"out": np.float32,
+                                            "x": np.float32,
+                                            "a": np.float32})
 
     bknl = lp.to_batched(knl, "nbatches", "out,x")
 
     ref_knl = lp.make_kernel(
          """ { [i,j,k]: 0<=i,j<n and 0<=k<nbatches} """,
          """out[k, i] = sum(j, a[i,j]*x[k, j])""")
-    ref_knl = lp.add_and_infer_dtypes(ref_knl, dict(out=np.float32,
-                                                    x=np.float32,
-                                                    a=np.float32))
+    ref_knl = lp.add_and_infer_dtypes(ref_knl, {"out": np.float32,
+                                                    "x": np.float32,
+                                                    "a": np.float32})
 
     a = np.random.randn(5, 5).astype(np.float32)
     x = np.random.randn(7, 5).astype(np.float32)
@@ -164,15 +164,15 @@ def test_to_batched_temp(ctx_factory):
              dtype=np.float32,
              shape=(),
              address_space=lp.AddressSpace.PRIVATE), "..."])
-    knl = lp.add_and_infer_dtypes(knl, dict(out=np.float32,
-                                            x=np.float32,
-                                            a=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"out": np.float32,
+                                            "x": np.float32,
+                                            "a": np.float32})
     ref_knl = lp.make_kernel(
          """ { [i,j]: 0<=i,j<n } """,
          """out[i] = sum(j, 2.0*a[i,j]*x[j])""")
-    ref_knl = lp.add_and_infer_dtypes(ref_knl, dict(out=np.float32,
-                                                    x=np.float32,
-                                                    a=np.float32))
+    ref_knl = lp.add_and_infer_dtypes(ref_knl, {"out": np.float32,
+                                                    "x": np.float32,
+                                                    "a": np.float32})
 
     bknl = lp.to_batched(knl, "nbatches", "out,x")
     bref_knl = lp.to_batched(ref_knl, "nbatches", "out,x")
@@ -186,7 +186,7 @@ def test_to_batched_temp(ctx_factory):
     # Checking that the program compiles and the logic is correct
     lp.auto_test_vs_ref(
             bref_knl, ctx, bknl,
-            parameters=dict(a=a, x=x, n=5, nbatches=7))
+            parameters={"a": a, "x": x, "n": 5, "nbatches": 7})
 
 
 def test_add_barrier(ctx_factory):
@@ -277,7 +277,7 @@ def test_alias_temporaries(ctx_factory):
     knl = lp.allocate_temporaries_for_base_storage(knl)
     lp.auto_test_vs_ref(
             ref_knl, ctx, knl,
-            parameters=dict(n=30))
+            parameters={"n": 30})
 
 
 def test_vectorize(ctx_factory):
@@ -289,10 +289,10 @@ def test_vectorize(ctx_factory):
         <> temp = 2*b[i]
         a[i] = temp
         """)
-    knl = lp.add_and_infer_dtypes(knl, dict(b=np.float32))
+    knl = lp.add_and_infer_dtypes(knl, {"b": np.float32})
     knl = lp.set_array_axis_names(knl, "a,b", "i")
     knl = lp.split_array_dim(knl, [("a", 0), ("b", 0)], 4,
-            split_kwargs=dict(slabs=(0, 1)))
+            split_kwargs={"slabs": (0, 1)})
 
     knl = lp.tag_array_axes(knl, "a,b", "c,vec")
     ref_knl = knl
@@ -305,7 +305,7 @@ def test_vectorize(ctx_factory):
 
     lp.auto_test_vs_ref(
             ref_knl, ctx, knl,
-            parameters=dict(n=30))
+            parameters={"n": 30})
 
 
 def test_extract_subst(ctx_factory):
@@ -363,10 +363,10 @@ def test_tag_data_axes(ctx_factory):
         lp.tag_array_axes(knl, "out", "N1,N0,c")
 
     knl = lp.tag_array_axes(knl, "out", "N1,N0,N2")
-    knl = lp.tag_inames(knl, dict(j="g.0", i="g.1"))
+    knl = lp.tag_inames(knl, {"j": "g.0", "i": "g.1"})
 
     lp.auto_test_vs_ref(ref_knl, ctx, knl,
-            parameters=dict(n=20))
+            parameters={"n": 20})
 
 
 def test_set_arg_order():
@@ -428,11 +428,11 @@ def test_precompute_confusing_subst_arguments(ctx_factory):
         b[i,j] = D(j)
         """, name="precomputer")
 
-    prog = lp.add_and_infer_dtypes(prog, dict(a=np.float32))
+    prog = lp.add_and_infer_dtypes(prog, {"a": np.float32})
 
     ref_prog = prog
 
-    prog = lp.tag_inames(prog, dict(j="g.1"))
+    prog = lp.tag_inames(prog, {"j": "g.1"})
     prog = lp.split_iname(prog, "i", 128, outer_tag="g.0", inner_tag="l.0")
 
     from loopy.symbolic import get_dependencies
@@ -444,7 +444,7 @@ def test_precompute_confusing_subst_arguments(ctx_factory):
 
     lp.auto_test_vs_ref(
             ref_prog, ctx, prog,
-            parameters=dict(n=12345))
+            parameters={"n": 12345})
 
 
 def test_precompute_nested_subst(ctx_factory):
@@ -458,7 +458,7 @@ def test_precompute_nested_subst(ctx_factory):
         b[i] = D
         """, name="precomputer")
 
-    prog = lp.add_and_infer_dtypes(prog, dict(a=np.float32))
+    prog = lp.add_and_infer_dtypes(prog, {"a": np.float32})
 
     ref_prog = prog
 
@@ -482,7 +482,7 @@ def test_precompute_nested_subst(ctx_factory):
 
     lp.auto_test_vs_ref(
             ref_prog, ctx, prog,
-            parameters=dict(n=12345))
+            parameters={"n": 12345})
 
 
 def test_precompute_with_preexisting_inames(ctx_factory):
@@ -517,7 +517,7 @@ def test_precompute_with_preexisting_inames(ctx_factory):
 
     lp.auto_test_vs_ref(
             ref_knl, ctx, knl,
-            parameters=dict(E=200))
+            parameters={"E": 200})
 
 
 def test_precompute_with_preexisting_inames_fail():