Touch-ups, tests, addressing Erik's feedback

Author: lwaern-intel

py/dml/c_backend.py

@@ -805,13 +805,13 @@ def generate_implement_method(device, ifacestruct, meth, indices):
             # method in DML
             raise EMETH(meth.site, None, 'interface method is variadic')
         for ((mp, mt), it) in zip(meth.inp, iface_input_types):
-            if safe_realtype_unconst(mt).cmp(safe_realtype_unconst(it)) != 0:
+            if not safe_realtype_unconst(mt).eq(safe_realtype_unconst(it)):
                 raise EARGT(meth.site, 'implement', meth.name,
                             mt, mp, it, 'method')
         if iface_num_outputs and dml.globals.dml_version != (1, 2):
             [(_, mt)] = meth.outp
-            if safe_realtype_unconst(mt).cmp(
-                    safe_realtype_unconst(func_type.output_type)) != 0:
+            if not safe_realtype_unconst(mt).eq(
+                    safe_realtype_unconst(func_type.output_type)):
                 raise EARGT(meth.site, 'implement', meth.name,
                             mt, '<return value>', func_type.output_type,
                             'method')

py/dml/clone_test.py

@@ -1507,7 +1507,7 @@ def eval_type(asttype, site, location, scope, extern=False, typename=None,
                     raise EBFLD(fsite, "field %s has wrong size" % name)
 
                 members[name] = (mtype, msb, lsb)
-            etype = TInt(width, False, members)
+            etype = TInt(width, False, members, label=typename)
         elif tag == 'typeof':
             expr = codegen_expression_maybe_nonvalue(info, location, scope)
             if isinstance(expr, NonValue):

py/dml/codegen.py

@@ -225,10 +225,16 @@ class lenient_typechecking(CompatFeature):
     macros, because in those scenarios DMLC can become wholly responsible for
     proper type checking.
 
-    While migrating from this feature, novel type errors due to uses of
-    `extern`:d macros can often be resolved by changing the signature of
-    the `extern` declaration to more accurately reflect the macro's effective
-    type.
+    While migrating away from this feature, the most common type errors that
+    its disablement introduces are due to discrepencies between pointer
+    types. In particular, implicitly discarding `const`-qualification of a
+    pointer's base type will never be tolerated, and `void` pointers are only
+    considered equivalent with any other pointer type in the same contexts as
+    C.
+
+    Novel type errors from uses of `extern`:d macros can often be resolved by
+    changing the signature of the `extern` declaration to more accurately
+    reflect the macro's effective type.
     '''
     short = "Make type checking inexact and lenient"
     last_api_version = api_7

py/dml/compat.py

@@ -1135,7 +1135,7 @@ def as_int(e):
     if t.is_endian:
         (fun, funtype) = t.get_load_fun()
         e = dml.expr.Apply(e.site, mkLit(e.site, fun, funtype), (e,), funtype)
-        if not compatible_types(realtype(e.ctype()), target_type):
+        if not realtype(e.ctype()).eq(target_type):
             e = mkCast(e.site, e, target_type)
         return e
     else:
@@ -1203,7 +1203,7 @@ def mkIfExpr(site, cond, texpr, fexpr):
             # Normally handled by expr_conditional; this only happens
             # in DMLC-internal mkIfExpr calls
             (result, rtype) = (texpr, ttype) if cond.value else (fexpr, ftype)
-            assert rtype.cmp(utype) == 0
+            assert rtype.eq(utype)
             return result
         return IfExpr(site, cond, texpr, fexpr, utype)
     else:
@@ -1225,8 +1225,8 @@ def mkIfExpr(site, cond, texpr, fexpr):
             if (isinstance(ttype, (TPtr, TArray))
                 and isinstance(ftype, (TPtr, TArray))
                 and (ttype.base.void or ftype.base.void
-                     or compatible_types(safe_realtype_unconst(ttype.base),
-                                         safe_realtype_unconst(ftype.base)))):
+                     or safe_realtype_unconst(ttype.base).eq(
+                         safe_realtype_unconst(ftype.base)))):
                 # if any branch is void, then the union is too
                 base = (ftype if ftype.base.void else ttype).base.clone()
                 # if any branch is const *, then the union is too
@@ -1235,8 +1235,7 @@ def mkIfExpr(site, cond, texpr, fexpr):
                               or shallow_const(ttype.base)
                               or shallow_const(ftype.base))
                 utype = TPtr(base)
-            elif compatible_types(safe_realtype_unconst(ttype),
-                                  safe_realtype_unconst(ftype)):
+            elif safe_realtype_unconst(ttype).eq(safe_realtype_unconst(ftype)):
                 utype = ttype
             else:
                 raise EBINOP(site, ':', texpr, fexpr)
@@ -1401,8 +1400,8 @@ def make(cls, site, lh, rh):
         if ((lhtype.is_arith and rhtype.is_arith)
             or (isinstance(lhtype, (TPtr, TArray))
                 and isinstance(rhtype, (TPtr, TArray))
-                and compatible_types(safe_realtype_unconst(lhtype.base),
-                                     safe_realtype_unconst(rhtype.base)))):
+                and safe_realtype_unconst(lhtype.base).eq(
+                    safe_realtype_unconst(rhtype.base)))):
             return cls.make_simple(site, lh, rh)
         raise EILLCOMP(site, lh, lhtype, rh, rhtype)
 
@@ -1565,7 +1564,7 @@ def make(cls, site, lh, rh):
                 return mkBoolConstant(site, (lhc.node is rhc.node
                                              and lhc_indices == rhc_indices))
             if (isinstance(lhc, HookRef) and isinstance(rhc, HookRef)
-                and lhtype.cmp(rhtype) == 0):
+                and lhtype.eq(rhtype)):
                 lh_indices = [idx.value for idx in lhc.indices]
                 rh_indices = [idx.value for idx in rhc.indices]
                 return mkBoolConstant(site, (lhc.hook is rhc.hook
@@ -1607,9 +1606,9 @@ def make(cls, site, lh, rh):
         if ((lhtype.is_arith and rhtype.is_arith)
             or (isinstance(lhtype, (TPtr, TArray))
                 and isinstance(rhtype, (TPtr, TArray))
-                and (compatible_types(safe_realtype_unconst(lhtype.base),
-                                      safe_realtype_unconst(rhtype.base))
-                     or lhtype.base.void or rhtype.base.void))
+                and (lhtype.base.void or rhtype.base.void
+                     or safe_realtype_unconst(lhtype.base).eq(
+                         safe_realtype_unconst(rhtype.base))))
             or (isinstance(lhtype, TBool) and isinstance(rhtype, TBool))):
             return Equals(site, lh, rh)
 
@@ -1618,7 +1617,7 @@ def make(cls, site, lh, rh):
             return IdentityEq(site, TraitObjIdentity(lh.site, lh),
                               TraitObjIdentity(rh.site, rh))
         if (isinstance(lhtype, THook) and isinstance(rhtype, THook)
-            and lhtype.cmp(rhtype) == 0):
+            and lhtype.eq(rhtype)):
             return IdentityEq(site, lh, rh)
 
         raise EILLCOMP(site, lh, lhtype, rh, rhtype)
@@ -2940,8 +2939,8 @@ def mkInterfaceMethodRef(site, iface_node, indices, method_name):
     if (not isinstance(ftype, TPtr)
         or not isinstance(ftype.base, TFunction)
         or not ftype.base.input_types
-        or TPtr(safe_realtype_unconst(TNamed('conf_object_t'))).cmp(
-            safe_realtype_unconst(ftype.base.input_types[0])) != 0):
+        or not TPtr(safe_realtype_unconst(TNamed('conf_object_t'))).eq(
+            safe_realtype_unconst(ftype.base.input_types[0]))):
         # non-method members are not accessible
         raise EMEMBER(site, struct_name, method_name)
 
@@ -4826,18 +4825,13 @@ def mkCast(site, expr, new_type):
         return Cast(site, expr, new_type)
     if isinstance(real, (TVoid, TArray, TFunction)):
         raise ECAST(site, expr, new_type)
-    if old_type.cmp(real) == 0:
-        if (old_type.is_int
-            and not old_type.is_endian
-            and dml.globals.compat_dml12_int(expr.site)):
+    if old_type.eq(real):
+        if (dml.globals.compat_dml12_int(expr.site)
+            and old_type.is_int
+            and not old_type.is_endian):
             # 1.2 integer expressions often lie about their actual type,
             # and require a "redundant" cast! Why yes, this IS horrid!
             return Cast(site, expr, new_type)
-        if real.is_int and real.members is not None:
-            # An integer type can be compatible with a bitfields without being
-            # equal to it, as DMLC will treat bitfields differently. Leverage
-            # Cast in this case
-            return Cast(site, expr, new_type)
         return mkRValue(expr)
     if isinstance(real, (TStruct, TExternStruct, TVector, TTraitList)):
         raise ECAST(site, expr, new_type)

py/dml/ctree.py

@@ -284,8 +284,8 @@ def framework_assertions(self):
     @subtest()
     def long_types(self):
         def tcmp(t1, t2):
-            left = t1.cmp(t2)
-            right = t2.cmp(t1)
+            left = t1.eq(t2)
+            right = t2.eq(t1)
             self.assertEqual(left, right)
             return left
         u = types.TLong(False)
@@ -301,8 +301,7 @@ def tcmp(t1, t2):
         # incompatible
         for t1 in int_types:
             for t2 in int_types:
-                self.assertEqual(tcmp(t1, t2),
-                                 0 if t1 is t2 else NotImplemented, (t1, t2))
+                self.assertEqual(tcmp(t1, t2), t1 is t2, (t1, t2))
 
         return [u.declaration('u') + ';',
                 'unsigned long *up UNUSED = &u;',
@@ -399,7 +398,7 @@ def int_cast_sequence(self):
             curr_expr = base
             for t in cast_sequence:
                 curr_expr = ctree.mkCast(site, curr_expr, t)
-            self.assertEqual(cast_sequence[-1].cmp(curr_expr.ctype()), 0)
+            self.assertTrue(cast_sequence[-1].eq(curr_expr.ctype()))
             self.assertEqual(curr_expr.expr, base)
 
     @subtest()
@@ -417,7 +416,7 @@ def int_cast_sequence_bit_increase(self):
     def cast_to_int(self, old_type, old_value, new_type, new_value):
         cast = ctree.mkCast(site, ctree.mkLit(site, old_value, old_type),
                             new_type)
-        self.assertTrue(types.compatible_types(cast.ctype(), new_type))
+        self.assertTrue(cast.ctype().eq(new_type))
         return ['EXPECT(%s == %s);' % (cast.read(), new_value)]
 
     def unendianed_type(self, endian_type):
@@ -460,8 +459,8 @@ def as_int(self, expr, value):
     ])
     def endian_int_cast(self, expr, endiantype):
         """Check that casting to endianint results in the right type"""
-        self.assertEqual(
-            ctree.mkCast(site, expr, endiantype).ctype().cmp(endiantype), 0)
+        self.assertTrue(
+            ctree.mkCast(site, expr, endiantype).ctype().eq(endiantype))
 
     @subtest([(targettype, endiantype)
               for targettype in (
@@ -483,7 +482,7 @@ def endian_int_cast_from(self, targettype, endiantype):
                             ctree.mkIntegerConstant(site, -5, True),
                             endiantype)
         cast = ctree.mkCast(site, expr, targettype)
-        self.assertEqual(cast.ctype().cmp(targettype), 0)
+        self.assertTrue(cast.ctype().eq(targettype))
         return ['%s UNUSED = %s;' % (targettype.declaration('x'), cast.read())]
 
     @subtest([(op, lh, rh)
@@ -535,7 +534,7 @@ def as_int_binop_coverage(self, op, lh, rh):
                types.TInt(64, True))])
     def as_int_ifexpr(self, lh, rh, expected_type):
         expr = ctree.mkIfExpr(site, variable('b', types.TBool()), lh, rh)
-        self.assertEqual(expr.type.cmp(expected_type), 0)
+        self.assertTrue(expr.type.eq(expected_type))
         return ["bool b = false;",
                 "EXPECT(%s == %s);" % (
                     expr.read(), ctree.mkCast(site, rh, expected_type).read())]
@@ -572,7 +571,7 @@ def as_int_unop_coverage(self, op, lh):
     def as_int_new_coverage(self, count):
         """Checks for as_int coverage"""
         expr = ctree.mkNew(site, types.TInt(8, False), count)
-        self.assertEqual(expr.type.cmp(types.TPtr(types.TInt(8, False))), 0)
+        self.assertTrue(expr.type.eq(types.TPtr(types.TInt(8, False))))
         return ["EXPECT(%s == 3);" % expr.count.read()]
 
     def expect_int_unop(self, const, unop, expected):
@@ -1025,8 +1024,7 @@ def add_sub_ptr(self, ptype):
             sub1 = ctree.mkSubtract(site, ptr, ctree.mkUnaryMinus(site, i))
             sub2 = ctree.mkSubtract(site, ptr, add1)
             for expr in (add1, add2, sub1):
-                self.assertTrue(types.compatible_types(
-                    expr.ctype().base, ptype))
+                self.assertTrue(expr.ctype().base.eq(ptype))
             self.expect_int_type(sub2.ctype(), True)
             stmts.extend([
                 'EXPECT(%s == exp);' % (add1.read(),),
@@ -1416,8 +1414,6 @@ def const_types(self):
             # abstract type
             types.IntegerType,
             # abstract type
-            types.ArchDependentIntegerType,
-            # abstract type
             types.StructType,
             # 1.2, weird
             types.TUnknown,

py/dml/ctree_test.py

@@ -740,9 +740,9 @@ def typecheck_method_override(m1, m2, location):
             type1 = safe_realtype_unconst(type1)
             type2 = safe_realtype_unconst(type2)
 
-            ok = (type1.cmp_fuzzy(type2)
+            ok = (type1.eq_fuzzy(type2)
                   if compat.lenient_typechecking in dml.globals.enabled_compat
-                  else type1.cmp(type2)) == 0
+                  else type1.eq(type2))
             if not ok:
                 raise EMETH(a1.site, a2.site,
                             f"mismatching types in input argument {n1}")
@@ -754,9 +754,9 @@ def typecheck_method_override(m1, m2, location):
             (_, type2) = eval_type(t2, a2.site, location, global_scope)
             type1 = safe_realtype_unconst(type1)
             type2 = safe_realtype_unconst(type2)
-            ok = (type1.cmp_fuzzy(type2)
+            ok = (type1.eq_fuzzy(type2)
                   if compat.lenient_typechecking in dml.globals.enabled_compat
-                  else type1.cmp(type2)) == 0
+                  else type1.eq(type2))
             if not ok:
                 msg = "mismatching types in return value"
                 if len(outp1) > 1:

py/dml/structure.py

@@ -403,18 +403,18 @@ def typecheck_method_override(left, right):
     for ((n, t0), (_, t1)) in zip(inp0, inp1):
         t0 = safe_realtype_unconst(t0)
         t1 = safe_realtype_unconst(t1)
-        ok = (t0.cmp_fuzzy(t1)
+        ok = (t0.eq_fuzzy(t1)
               if compat.lenient_typechecking in dml.globals.enabled_compat
-              else t0.cmp(t1)) == 0
+              else t0.eq(t1))
         if not ok:
             raise EMETH(site0, site1,
                         "mismatching types in input argument %s" % (n,))
     for (i, ((_, t0), (_, t1))) in enumerate(zip(outp0, outp1)):
         t0 = safe_realtype_unconst(t0)
         t1 = safe_realtype_unconst(t1)
-        ok = (t0.cmp_fuzzy(t1)
+        ok = (t0.eq_fuzzy(t1)
               if compat.lenient_typechecking in dml.globals.enabled_compat
-              else t0.cmp(t1)) == 0
+              else t0.eq(t1))
         if not ok:
             raise EMETH(site0, site1,
                         "mismatching types in output argument %d" % (i + 1,))