9786d0c0e3
This warning is usually quite handy, but is problematic in tests:
although it can be suppressed by using Fragment.get on elaboratable,
that is not always possible, in particular when writing tests for
exceptions raised by __init__, e.g.:
def test_wrong_csr_bus(self):
with self.assertRaisesRegex(ValueError, r"blah blah"):
WishboneCSRBridge(csr_bus=object())
In theory, it should be possible to suppress warnings per-module
and even per-line using code such as:
import re, warnings
from nmigen.hdl.ir import UnusedElaboratable
warnings.filterwarnings("ignore", category=UnusedElaboratable,
module=re.escape(__name__))
Unfortunately, not only is this code quite convoluted, but it also
does not actually work; we are using warnings.warn_explicit() because
we collect source locations on our own, but it requires the caller
to extract the __warningregistry__ dictionary from module globals,
or warning suppression would not work. Not only is this not feasible
in most diagnostic sites in nMigen, but also I never got it to work
anyway, even when passing all of module, registry, and module_globals
to warn_explicit().
Instead, use a magic comment at the start of a file to do this job,
which might not be elegant but is simple and practical. For now,
only UnusedElaboratable can be suppressed with it, but in future,
other linter parameters may become tweakable this way.
117 lines
2.9 KiB
Python
117 lines
2.9 KiB
Python
import contextlib
|
|
import functools
|
|
import warnings
|
|
import linecache
|
|
import re
|
|
from collections import OrderedDict
|
|
from collections.abc import Iterable
|
|
from contextlib import contextmanager
|
|
|
|
from .utils import *
|
|
|
|
|
|
__all__ = ["flatten", "union" , "log2_int", "bits_for", "memoize", "final", "deprecated",
|
|
"get_linter_options", "get_linter_option"]
|
|
|
|
|
|
def flatten(i):
|
|
for e in i:
|
|
if isinstance(e, Iterable):
|
|
yield from flatten(e)
|
|
else:
|
|
yield e
|
|
|
|
|
|
def union(i, start=None):
|
|
r = start
|
|
for e in i:
|
|
if r is None:
|
|
r = e
|
|
else:
|
|
r |= e
|
|
return r
|
|
|
|
|
|
def memoize(f):
|
|
memo = OrderedDict()
|
|
@functools.wraps(f)
|
|
def g(*args):
|
|
if args not in memo:
|
|
memo[args] = f(*args)
|
|
return memo[args]
|
|
return g
|
|
|
|
|
|
def final(cls):
|
|
def init_subclass():
|
|
raise TypeError("Subclassing {}.{} is not supported"
|
|
.format(cls.__module__, cls.__name__))
|
|
cls.__init_subclass__ = init_subclass
|
|
return cls
|
|
|
|
|
|
def deprecated(message, stacklevel=2):
|
|
def decorator(f):
|
|
@functools.wraps(f)
|
|
def wrapper(*args, **kwargs):
|
|
warnings.warn(message, DeprecationWarning, stacklevel=stacklevel)
|
|
return f(*args, **kwargs)
|
|
return wrapper
|
|
return decorator
|
|
|
|
|
|
def _ignore_deprecated(f=None):
|
|
if f is None:
|
|
@contextlib.contextmanager
|
|
def context_like():
|
|
with warnings.catch_warnings():
|
|
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
|
|
yield
|
|
return context_like()
|
|
else:
|
|
@functools.wraps(f)
|
|
def decorator_like(*args, **kwargs):
|
|
with warnings.catch_warnings():
|
|
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
|
|
f(*args, **kwargs)
|
|
return decorator_like
|
|
|
|
|
|
def extend(cls):
|
|
def decorator(f):
|
|
if isinstance(f, property):
|
|
name = f.fget.__name__
|
|
else:
|
|
name = f.__name__
|
|
setattr(cls, name, f)
|
|
return decorator
|
|
|
|
|
|
def get_linter_options(filename):
|
|
first_line = linecache.getline(filename, 1)
|
|
if first_line:
|
|
match = re.match(r"^#\s*nmigen:\s*((?:\w+=\w+\s*)(?:,\s*\w+=\w+\s*)*)\n$", first_line)
|
|
if match:
|
|
return dict(map(lambda s: s.strip().split("=", 2), match.group(1).split(",")))
|
|
return dict()
|
|
|
|
|
|
def get_linter_option(filename, name, type, default):
|
|
options = get_linter_options(filename)
|
|
if name not in options:
|
|
return default
|
|
|
|
option = options[name]
|
|
if type is bool:
|
|
if option in ("1", "yes", "enable"):
|
|
return True
|
|
if option in ("0", "no", "disable"):
|
|
return False
|
|
return default
|
|
if type is int:
|
|
try:
|
|
return int(option, 0)
|
|
except ValueError:
|
|
return default
|
|
assert False
|