Fix pylint issue in numba_dpex/experimental/_kernel_dpcpp_spirv_overloads/_atomic_ref_overloads.py

Fix pylint issue in numba_dpex/experimental/kernel_dispatcher.py

Fix pylint issues in numba_dpex/experimental/literal_intenum_type.py

Fix pylint issues in numba_dpex/experimental/target.py

Fix pylint issues in numba_dpex/experimental/typeof.py

Author: chudur-budur

numba_dpex/experimental/_kernel_dpcpp_spirv_overloads/_atomic_ref_overloads.py

@@ -94,12 +94,12 @@ def gen(context, builder, sig, args):
                 atomic_ref_dtype,
             ],
         )
-        fn = cgutils.get_or_insert_function(
+        func = cgutils.get_or_insert_function(
             builder.module,
             llvmir.FunctionType(retty, spirv_fn_arg_types),
             mangled_fn_name,
         )
-        fn.calling_convention = CC_SPIR_FUNC
+        func.calling_convention = CC_SPIR_FUNC
         spirv_memory_semantics_mask = get_memory_semantics_mask(
             atomic_ref_ty.memory_order
         )
@@ -112,7 +112,7 @@ def gen(context, builder, sig, args):
             args[1],
         ]
 
-        builder.call(fn, fn_args)
+        builder.call(func, fn_args)
 
     return sig, gen
 

numba_dpex/experimental/kernel_dispatcher.py

@@ -270,12 +270,12 @@ def _compile_cached(
                     cres.fndesc.llvm_func_name + ".ll",
                     "w",
                     encoding="UTF-8",
-                ) as f:
-                    f.write(cres.library.final_module)
+                ) as fptr:
+                    fptr.write(cres.library.final_module)
 
-        except errors.TypingError as e:
-            self._failed_cache[key] = e
-            return False, e
+        except errors.TypingError as err:
+            self._failed_cache[key] = err
+            return False, err
 
         return True, _KernelCompileResult(*kcres_attrs)
 
@@ -342,18 +342,18 @@ def typeof_pyval(self, val):
         # Not going through the resolve_argument_type() indirection
         # can save a couple µs.
         try:
-            tp = typeof(val, Purpose.argument)
-            if isinstance(tp, types.Array) and not isinstance(tp, USMNdArray):
+            typ = typeof(val, Purpose.argument)
+            if isinstance(typ, types.Array) and not isinstance(typ, USMNdArray):
                 raise UnsupportedKernelArgumentError(
                     type=str(type(val)), value=val
                 )
         except ValueError:
-            tp = types.pyobject
+            typ = types.pyobject
         else:
-            if tp is None:
-                tp = types.pyobject
-        self._types_active_call.append(tp)
-        return tp
+            if typ is None:
+                typ = types.pyobject
+        self._types_active_call.append(typ)
+        return typ
 
     def add_overload(self, cres):
         args = tuple(cres.signature.args)
@@ -430,14 +430,14 @@ def cb_llvm(dur):
                         kcres: _KernelCompileResult = compiler.compile(
                             args, return_type
                         )
-                    except errors.ForceLiteralArg as e:
+                    except errors.ForceLiteralArg as err:
 
                         def folded(args, kws):
                             return self._compiler.fold_argument_types(
                                 args, kws
                             )[1]
 
-                        raise e.bind_fold_arguments(folded)
+                        raise err.bind_fold_arguments(folded)
                     self.add_overload(kcres)
 
                     kcres.target_context.insert_user_function(

numba_dpex/experimental/literal_intenum_type.py

@@ -47,9 +47,9 @@ def can_convert_to(self, typingctx, other) -> bool:
 
 
 @box(IntEnumLiteral)
-def box_literal_integer(typ, val, c):
+def box_literal_integer(typ, val, ctx):
     """Defines how a Numba representation for an IntEnumLiteral object should
     be converted to a PyObject* object and returned back to Python.
     """
-    val = c.context.cast(c.builder, val, typ, typ.literal_type)
-    return c.box(typ.literal_type, val)
+    val = ctx.context.cast(ctx.builder, val, typ, typ.literal_type)
+    return ctx.box(typ.literal_type, val)

numba_dpex/experimental/target.py

@@ -52,29 +52,29 @@ def resolve_value_type(self, val):
         ValueError is raised for unsupported types.
         """
 
-        ty = super().resolve_value_type(val)
+        typ = super().resolve_value_type(val)
 
-        if isinstance(ty, IntEnumClass) and issubclass(val, FlagEnum):
-            ty = IntEnumLiteral(val)
+        if isinstance(typ, IntEnumClass) and issubclass(val, FlagEnum):
+            typ = IntEnumLiteral(val)
 
-        return ty
+        return typ
 
     def resolve_getattr(self, typ, attr):
         """
         Resolve getting the attribute *attr* (a string) on the Numba type.
         The attribute's type is returned, or None if resolution failed.
         """
-        ty = None
+        retty = None
 
         if isinstance(typ, IntEnumLiteral):
             try:
                 attrval = getattr(typ.literal_value, attr).value
-                ty = types.IntegerLiteral(attrval)
+                retty = types.IntegerLiteral(attrval)
             except ValueError:
                 pass
         else:
-            ty = super().resolve_getattr(typ, attr)
-        return ty
+            retty = super().resolve_getattr(typ, attr)
+        return retty
 
 
 #  pylint: disable=W0223

numba_dpex/experimental/typeof.py

@@ -14,18 +14,18 @@
 
 
 @typeof_impl.register(AtomicRef)
-def typeof_atomic_ref(val: AtomicRef, c) -> AtomicRefType:
+def typeof_atomic_ref(val: AtomicRef, ctx) -> AtomicRefType:
     """Returns a ``numba_dpex.experimental.dpctpp_types.AtomicRefType``
     instance for a Python AtomicRef object.
 
     Args:
         val (AtomicRef): Instance of the AtomicRef type.
-        c : Numba typing context used for type inference.
+        ctx : Numba typing context used for type inference.
 
     Returns: AtomicRefType object corresponding to the AtomicRef object.
 
     """
-    dtype = typeof_impl(val.ref, c)
+    dtype = typeof_impl(val.ref, ctx)
 
     return AtomicRefType(
         dtype=dtype,