Change --deprecate to --no-compat

This also included some renames and change in polarities; in particular,
all deprecated features are now disabled by default, as required by some
unit tests.

Author: mandolaerik

MODULEINFO

@@ -43,9 +43,9 @@ Make: dmlc
     $(HOST)/bin/dml/python/dml/c_backend.py
     $(HOST)/bin/dml/python/dml/g_backend.py
     $(HOST)/bin/dml/python/dml/codegen.py
+    $(HOST)/bin/dml/python/dml/compat.py
     $(HOST)/bin/dml/python/dml/crep.py
     $(HOST)/bin/dml/python/dml/ctree.py
-    $(HOST)/bin/dml/python/dml/deprecations.py
     $(HOST)/bin/dml/python/dml/dmllex.py
     $(HOST)/bin/dml/python/dml/dmllex12.py
     $(HOST)/bin/dml/python/dml/dmllex14.py

Makefile

@@ -13,6 +13,7 @@ PYFILES := dml/__init__.py			\
 	  dml/c_backend.py			\
 	  dml/g_backend.py			\
 	  dml/codegen.py			\
+          dml/compat.py				\
           dml/crep.py				\
           dml/ctree.py				\
           dml/template.py			\

deprecations_to_md.py

@@ -6,13 +6,13 @@
 [path_to_dml, header, outfile] = sys.argv[1:]
 sys.path.append(path_to_dml)
 
-from dml.deprecations import deprecations
+from dml.compat import features
 from dml.env import api_versions
 
 api_map = {v: k for (k, v) in api_versions().items()}
 with open(outfile, 'w') as f:
     f.write(Path(header).read_text())
-    for (ver, deps) in deprecations.items():
+    for (ver, deps) in features.items():
         if deps and ver in api_map:
             f.write(
                 f"### Features available up to --simics-api={api_map[ver]}\n")

doc/1.4/deprecations-header.md

@@ -61,10 +61,10 @@ some uses, in particular:
 DMLC provides a command-line flag `--api-version` to specify the API version to
 be used for a model. When building with the standard Simics build system, this is controlled by the `SIMICS_API_VERSION` variable in `make`, or the `SIMICS_API`/`MODULE_SIMICS_API` variable in `CMake`.
 
-DMLC also provides the <code>--deprecate=_tag_</code> flag, which disables the
+DMLC also provides the <code>--no-compat=_tag_</code> flag, which disables the
 feature represented by _`tag`_. The available tags are listed in the next
 section. The tag also controls the name of a global boolean parameter that the
 DML program may use to check whether the feature is available. The parameter's
-name is the tag name preceded by `_deprecate_`.
+name is the tag name preceded by `_compat_`.
 
 ## List of deprecated features

lib/1.2/dml-builtins.dml

@@ -206,8 +206,8 @@ template device {
 
     parameter simics_api_version auto;
 
-    parameter _deprecate_port_proxy_ifaces auto;
-    parameter _deprecate_port_proxy_attrs auto;
+    parameter _compat_port_proxy_ifaces auto;
+    parameter _compat_port_proxy_attrs auto;
 
     // automatic parameters
     parameter obj                       auto;

lib/1.4/dml-builtins.dml

@@ -543,8 +543,8 @@ template device {
         || simics_api_version == "4.8";
     param _api_6_or_older = simics_api_version == "6" || _api_5_or_older;
 
-    param _deprecate_port_proxy_ifaces auto;
-    param _deprecate_port_proxy_attrs auto;
+    param _compat_port_proxy_ifaces auto;
+    param _compat_port_proxy_attrs auto;
 
     // automatic parameters
     param obj                       auto;

py/dml/c_backend.py

@@ -13,7 +13,7 @@
 from pathlib import Path
 
 from . import objects, logging, crep, output, ctree, serialize, structure
-from . import traits, deprecations
+from . import traits, compat
 import dml.globals
 from .structure import get_attr_name, port_class_ident, need_port_proxy_attrs
 from .logging import *
@@ -888,8 +888,7 @@ def generate_implement(code, device, impl):
         # descendants of the device object
         if (port.parent is dml.globals.device
             and port.objtype in {'port', 'bank'}
-            and (deprecations.port_proxy_ifaces
-                 not in dml.globals.enabled_deprecations)):
+            and compat.port_proxy_ifaces in dml.globals.enabled_compat):
             if port.local_dimensions() == 0:
                 code.out("static const %s = %s;\n" % (
                     ifacetype.declaration('port_iface'),

py/dml/codegen.py

@@ -11,7 +11,7 @@
 import math
 
 from . import objects, crep, ctree, ast, int_register, logging, serialize
-from . import dmlparse, output, deprecations
+from . import dmlparse, output, compat
 from .logging import *
 from .expr import *
 from .ctree import *
@@ -1079,7 +1079,7 @@ def subast_has_dollar(expr_ast):
 @expression_dispatcher
 def expr_unop(tree, location, scope):
     [op, rh_ast] = tree.args
-    if (deprecations.dml12_misc not in dml.globals.enabled_deprecations
+    if (compat.dml12_misc in dml.globals.enabled_compat
         and op == 'sizeof' and rh_ast.kind == 'variable_dml12'):
         var = rh_ast.args[0]
         if var in typedefs and scope.lookup(var) is None:
@@ -1120,7 +1120,7 @@ def expr_unop(tree, location, scope):
                     return ctree.AddressOfMethod(tree.site, func)
         raise rh.exc()
     if   op == '!':
-        if deprecations.dml12_not not in dml.globals.enabled_deprecations:
+        if compat.dml12_not in dml.globals.enabled_compat:
             t = rh.ctype()
             if isinstance(safe_realtype(t), TInt) and subast_has_dollar(rh_ast):
                 # A previous bug caused DMLC to permit expressions on
@@ -1142,7 +1142,7 @@ def expr_unop(tree, location, scope):
     elif op == 'post++':  return mkPostInc(tree.site, rh)
     elif op == 'post--':  return mkPostDec(tree.site, rh)
     elif op == 'sizeof':
-        if (deprecations.dml12_misc in dml.globals.enabled_deprecations
+        if (compat.dml12_misc not in dml.globals.enabled_compat
             and not isinstance(rh, ctree.LValue)):
             raise ERVAL(rh.site, 'sizeof')
         return codegen_sizeof(tree.site, rh)
@@ -1319,7 +1319,7 @@ def expr_cast(tree, location, scope):
     for (site, _) in struct_defs:
         report(EANONSTRUCT(site, "'cast' expression"))
 
-    if (deprecations.dml12_misc not in dml.globals.enabled_deprecations
+    if (compat.dml12_misc in dml.globals.enabled_compat
         and isinstance(expr, InterfaceMethodRef)):
         # Workaround for SIMICS-9868
         return mkLit(tree.site, "%s->%s" % (
@@ -1525,7 +1525,7 @@ def eval_type(asttype, site, location, scope, extern=False, typename=None,
             etype = TInt(width, False, members)
         elif tag == 'typeof':
             expr = codegen_expression_maybe_nonvalue(info, location, scope)
-            if (deprecations.dml12_misc in dml.globals.enabled_deprecations
+            if (compat.dml12_misc not in dml.globals.enabled_compat
                 and not isinstance(expr, ctree.LValue)
                 # for compatibility with dml-builtins, using 1.2
                 and not isinstance(expr, ctree.RegisterWithFields)):
@@ -1981,7 +1981,7 @@ def stmt_local(stmt, location, scope):
     def convert_decl(decl_ast):
         (name, asttype) = decl_ast.args
         if (dml.globals.dml_version == (1, 2)
-            and deprecations.dml12_misc in dml.globals.enabled_deprecations):
+            and compat.dml12_misc not in dml.globals.enabled_compat):
             check_varname(stmt.site, name)
         (struct_decls, etype) = eval_type(asttype, stmt.site, location, scope)
         stmts.extend(mkStructDefinition(site, t) for (site, t) in struct_decls)
@@ -2545,7 +2545,7 @@ def stmt_assert(stmt, location, scope):
 @statement_dispatcher
 def stmt_goto(stmt, location, scope):
     [label] = stmt.args
-    if deprecations.dml12_misc in dml.globals.enabled_deprecations:
+    if compat.dml12_misc not in dml.globals.enabled_compat:
         report(ESYNTAX(stmt.site, 'goto', 'goto statement not allowed'))
     return [mkGoto(stmt.site, label)]
 
@@ -2998,7 +2998,7 @@ def stmt_select(stmt, location, scope):
                 if_chain = mkIf(cond.site, cond, stmt, if_chain)
             return [if_chain]
         raise lst.exc()
-    elif (deprecations.dml12_misc not in dml.globals.enabled_deprecations
+    elif (compat.dml12_misc in dml.globals.enabled_compat
           and isinstance(lst.ctype(), TVector)):
         itervar = lookup_var(stmt.site, scope, itername)
         if not itervar:
@@ -3272,19 +3272,19 @@ def common_inline(site, method, indices, inargs, outargs):
 
     if dml.globals.debuggable:
         if method.fully_typed and (
-                deprecations.dml12_inline in dml.globals.enabled_deprecations
+                compat.dml12_inline not in dml.globals.enabled_compat
                 or all(not arg.constant for arg in inargs)):
             # call method instead of inlining it
             func = method_instance(method)
         else:
             # create a specialized method instance based on parameter
             # types, and call that
-            intypes = tuple(arg if ((ptype is None or deprecations.dml12_inline
-                                     not in dml.globals.enabled_deprecations)
-                                    and (arg.constant or undefined(arg)))
-                            else methfunc_param(ptype, arg)
-                            for ((pname, ptype), arg)
-                            in zip(method.inp, inargs))
+            intypes = tuple(
+                arg if ((ptype is None
+                         or compat.dml12_inline in dml.globals.enabled_compat)
+                        and (arg.constant or undefined(arg)))
+                else methfunc_param(ptype, arg)
+                for ((pname, ptype), arg) in zip(method.inp, inargs))
             outtypes = tuple(methfunc_param(ptype, arg)
                              for ((pname, ptype), arg)
                              in zip(method.outp, outargs))
@@ -3504,9 +3504,9 @@ def codegen_inline(site, meth_node, indices, inargs, outargs,
 
             if inhibit_copyin or undefined(arg):
                 param_scope.add(ExpressionSymbol(parmname, arg, arg.site))
-            elif arg.constant and (parmtype is None
-                                   or deprecations.dml12_inline
-                                   not in dml.globals.enabled_deprecations):
+            elif arg.constant and (
+                    parmtype is None
+                    or compat.dml12_inline in dml.globals.enabled_compat):
                 # Constants must be passed directly to
                 # provide constant folding.  Other values are stored in a
                 # local variable to improve type checking and variable
@@ -3721,7 +3721,7 @@ def codegen_method_func(func):
     inline_scope = MethodParamScope(global_scope)
     for (name, e) in func.inp:
         if dml.globals.dml_version == (1, 2) and (
-                deprecations.dml12_misc in dml.globals.enabled_deprecations):
+                compat.dml12_misc not in dml.globals.enabled_compat):
             check_varname(method.site, name)
         if isinstance(e, Expression):
             inlined_arg = (
@@ -3929,7 +3929,7 @@ def codegen_call(site, meth_node, indices, inargs, outargs):
     require_fully_typed(site, meth_node)
     func = method_instance(meth_node)
 
-    if deprecations.dml12_misc not in dml.globals.enabled_deprecations:
+    if compat.dml12_misc in dml.globals.enabled_compat:
         # For backward compatibility. See bug 21367.
         inargs = [mkCast(site, arg, TPtr(TNamed('char')))
                   if isinstance(arg, StringConstant) else arg

py/dml/deprecations.py renamed to py/dml/compat.py

@@ -6,7 +6,7 @@
 from . import env
 
 
-class DeprecatedFeature(abc.ABC):
+class CompatFeature(abc.ABC):
     def tag(self):
         return self.__class__.__name__
 
@@ -20,25 +20,25 @@ def short(self): pass
     def last_api_version(self): pass
 
 
-# API version -> tag -> deprecation
-deprecations: dict[str, dict[str, DeprecatedFeature]] = {
+# API version -> tag -> feature
+features: dict[str, dict[str, CompatFeature]] = {
     api: {} for api in env.api_versions().values()}
 
 
-def deprecation(cls: type[DeprecatedFeature]):
-    assert issubclass(cls, DeprecatedFeature)
+def feature(cls: type[CompatFeature]):
+    assert issubclass(cls, CompatFeature)
     singleton = cls()
-    deprecations[cls.last_api_version][singleton.tag()] = singleton
+    features[cls.last_api_version][singleton.tag()] = singleton
     return singleton
 
 
-@deprecation
-class port_proxy_ifaces(DeprecatedFeature):
+@feature
+class port_proxy_ifaces(CompatFeature):
     '''Version 5 and earlier of Simics relied on interface ports (as
     registered by the `SIM_register_port_interface` API function) for
     exposing the interfaces of ports and banks. In newer versions of
     Simics, interfaces are instead exposed on separate configuration
-    objects.  When this deprecation is not enabled, old-style
+    objects.  When this feature is enabled, old-style
     interface ports are created as proxies to the interfaces on the
     respective port objects. Such proxies are not created for all
     banks and ports; e.g., banks inside groups were not allowed in
@@ -49,23 +49,23 @@ class port_proxy_ifaces(DeprecatedFeature):
     last_api_version = 6
 
 
-@deprecation
-class port_proxy_attrs(DeprecatedFeature):
+@feature
+class port_proxy_attrs(CompatFeature):
     '''In Simics 5, configuration attributes for `connect`,
     `attribute` and `register` objects inside banks and ports were
     register on the device object, named like
     <code><em>bankname</em>_<em>attrname</em></code>. Such proxy
-    attributes are only created When this deprecation is not enabled.
+    attributes are only created When this feature is enabled.
     Proxy attributes are not created for all banks and ports, in the
-    same manner as documented in the `port_proxy_ifaces` deprecation.
+    same manner as documented in the `port_proxy_ifaces` feature.
     '''
     short = ("Don't generate top-level proxy attributes"
              + " for attributes in banks and ports")
     last_api_version = 6
 
 
-@deprecation
-class dml12_inline(DeprecatedFeature):
+@feature
+class dml12_inline(CompatFeature):
     '''When inlining a method using `inline` in a DML 1.2 device,
     constant parameters passed in typed arguments are also inlined,
     unless compiling with `-g`.
@@ -75,24 +75,24 @@ class dml12_inline(DeprecatedFeature):
 
 
 # separate class only because last_api_version differs
-@deprecation
-class dml12_not(DeprecatedFeature):
+@feature
+class dml12_not(CompatFeature):
     '''DML 1.2-specific: the operand of the `!` operator is not
     type-checked; in particular, negation expressions on the form
     `!$reg`, where `reg` is a register, are permitted'''
     short = "Disallow ! operator on register references in DML 1.2"
     last_api_version = 5
 
 
-@deprecation
-class dml12_misc(DeprecatedFeature):
-    '''A number of minor language quirks in DML 1.2 were cleaned up in
-    DML 1.4; enabling this deprecation switches to the DML 1.4
-    semantics for these. This includes:
+@feature
+class dml12_misc(CompatFeature):
+    '''This compatibility feature preserves a number of minor language quirks
+    that were originally in DML 1.2, but were cleaned up in
+    DML 1.4. When this feature is enabled, DML 1.2 will permit the following:
 
-    * `sizeof(typename)` is permitted with a warning message (`WSIZEOFTYPE`)
+    * `sizeof(typename)` (see `WSIZEOFTYPE`)
 
-    * the `typeof` operator an expression that isn't an lvalue
+    * the `typeof` operator on an expression that isn't an lvalue
 
     * the `goto` statement
 

py/dml/crep.py

@@ -10,7 +10,7 @@
 from .logging import *
 from .expr_util import *
 from .messages import *
-from . import deprecations
+from . import compat
 
 __all__ = (
     'cname',
@@ -75,7 +75,7 @@ def cname(node):
         # this is weird... kept for compatibility
         name = param_str(node, 'c_name').replace('-', '_')
         if name != node.name and (
-                deprecations.dml12_misc in dml.globals.enabled_deprecations):
+                compat.dml12_misc not in dml.globals.enabled_compat):
             report(WDEPRECATED(param_expr_site(node, 'c_name'),
                                'parameter c_name'))
         return name
@@ -178,7 +178,7 @@ def node_storage_type_dml12(node, site):
         else:
             return None
     elif node.objtype == 'implement':
-        if deprecations.dml12_misc not in dml.globals.enabled_deprecations:
+        if compat.dml12_misc in dml.globals.enabled_compat:
             typename = param_str(node, 'c_type')
             t = TNamed(typename)
             t.declaration_site = node.site
@@ -228,7 +228,7 @@ def conf_object(site, node, indices):
                            cref_portobj(node, indices[:node.dimensions]))
 
 def cloggroup(name):
-    if deprecations.dml12_misc not in dml.globals.enabled_deprecations:
+    if compat.dml12_misc in dml.globals.enabled_compat:
         return name
     else:
         return '_dml_loggroup_' + name