Remove everything deprecated in nmigen 0.1.

Closes #275.

nmigen/compat/fhdl/specials.py

@@ -7,6 +7,7 @@ from ...hdl.mem import Memory as NativeMemory
 from ...hdl.ir import Fragment, Instance
 from ...hdl.dsl import Module
 from .module import Module as CompatModule
+from .structure import Signal
 from ...lib.io import Pin
 
 

nmigen/compat/fhdl/structure.py

@@ -1,8 +1,14 @@
+import builtins
+import warnings
 from collections import OrderedDict
 
+from ...utils import bits_for
 from ..._utils import deprecated, extend
 from ...hdl import ast
-from ...hdl.ast import (DUID, Value, Signal, Mux, Slice as _Slice, Cat, Repl, Const, C,
+from ...hdl.ast import (DUID,
+                        Shape, signed, unsigned,
+                        Value, Const, C, Mux, Slice as _Slice, Part, Cat, Repl,
+                        Signal as NativeSignal,
                         ClockSignal, ResetSignal,
                         Array, ArrayProxy as _ArrayProxy)
 from ...hdl.cd import ClockDomain
@@ -17,11 +23,47 @@ def wrap(v):
     return Value.cast(v)
 
 
-@extend(Cat)
-@property
-@deprecated("instead of `Cat.l`, use `Cat.parts`")
-def l(self):
-    return self.parts
+class CompatSignal(NativeSignal):
+    def __init__(self, bits_sign=None, name=None, variable=False, reset=0,
+                 reset_less=False, name_override=None, min=None, max=None,
+                 related=None, attr=None, src_loc_at=0, **kwargs):
+        if min is not None or max is not None:
+            warnings.warn("instead of `Signal(min={min}, max={max})`, "
+                          "use `Signal(range({min}, {max}))`"
+                          .format(min=min or 0, max=max or 2),
+                          DeprecationWarning, stacklevel=2 + src_loc_at)
+
+        if bits_sign is None:
+            if min is None:
+                min = 0
+            if max is None:
+                max = 2
+            max -= 1  # make both bounds inclusive
+            if min > max:
+                raise ValueError("Lower bound {} should be less or equal to higher bound {}"
+                                 .format(min, max + 1))
+            sign = min < 0 or max < 0
+            if min == max:
+                bits = 0
+            else:
+                bits = builtins.max(bits_for(min, sign), bits_for(max, sign))
+            shape = signed(bits) if sign else unsigned(bits)
+        else:
+            if not (min is None and max is None):
+                raise ValueError("Only one of bits/signedness or bounds may be specified")
+            shape = bits_sign
+
+        super().__init__(shape=shape, name=name_override or name,
+                         reset=reset, reset_less=reset_less,
+                         attrs=attr, src_loc_at=1 + src_loc_at, **kwargs)
+
+
+Signal = CompatSignal
+
+
+@deprecated("instead of `Constant`, use `Const`")
+def Constant(value, bits_sign=None):
+    return Const(value, bits_sign)
 
 
 @deprecated("instead of `Replicate`, use `Repl`")
@@ -29,9 +71,45 @@ def Replicate(v, n):
     return Repl(v, n)
 
 
-@deprecated("instead of `Constant`, use `Const`")
-def Constant(value, bits_sign=None):
-    return Const(value, bits_sign)
+@extend(Const)
+@property
+@deprecated("instead of `.nbits`, use `.width`")
+def nbits(self):
+    return self.width
+
+
+@extend(NativeSignal)
+@property
+@deprecated("instead of `.nbits`, use `.width`")
+def nbits(self):
+    return self.width
+
+
+@extend(NativeSignal)
+@NativeSignal.nbits.setter
+@deprecated("instead of `.nbits = x`, use `.width = x`")
+def nbits(self, value):
+    self.width = value
+
+
+@extend(NativeSignal)
+@deprecated("instead of `.part`, use `.bit_select`")
+def part(self, offset, width):
+    return Part(self, offset, width, src_loc_at=2)
+
+
+@extend(Cat)
+@property
+@deprecated("instead of `.l`, use `.parts`")
+def l(self):
+    return self.parts
+
+
+@extend(ast.Operator)
+@property
+@deprecated("instead of `.op`, use `.operator`")
+def op(self):
+    return self.operator
 
 
 @extend(_ArrayProxy)
@@ -47,7 +125,7 @@ class If(ast.Switch):
         cond = Value.cast(cond)
         if len(cond) != 1:
             cond = cond.bool()
-        super().__init__(cond, {("1",): ast.Statement.wrap(stmts)})
+        super().__init__(cond, {("1",): ast.Statement.cast(stmts)})
 
     @deprecated("instead of `.Elif(cond, ...)`, use `with m.Elif(cond): ...`")
     def Elif(self, cond, *stmts):
@@ -55,13 +133,13 @@ class If(ast.Switch):
         if len(cond) != 1:
             cond = cond.bool()
         self.cases = OrderedDict((("-" + k,), v) for (k,), v in self.cases.items())
-        self.cases[("1" + "-" * len(self.test),)] = ast.Statement.wrap(stmts)
+        self.cases[("1" + "-" * len(self.test),)] = ast.Statement.cast(stmts)
         self.test = Cat(self.test, cond)
         return self
 
     @deprecated("instead of `.Else(...)`, use `with m.Else(): ...`")
     def Else(self, *stmts):
-        self.cases[()] = ast.Statement.wrap(stmts)
+        self.cases[()] = ast.Statement.cast(stmts)
         return self
 
 
@@ -100,7 +178,7 @@ class Case(ast.Switch):
         elif isinstance(key, str) and key == "default":
             key = ()
         else:
-            key = ("{:0{}b}".format(wrap(key).value, len(self.test)),)
+            key = ("{:0{}b}".format(ast.Value.cast(key).value, len(self.test)),)
         stmts = self.cases[key]
         del self.cases[key]
         self.cases[()] = stmts

nmigen/compat/genlib/fifo.py

@@ -14,6 +14,90 @@ class CompatFIFOInterface(NativeFIFOInterface):
         del self.fwft
 
 
+@extend(NativeFIFOInterface)
+@property
+@deprecated("instead of `fifo.din`, use `fifo.w_data`")
+def din(self):
+    return self.w_data
+
+
+@extend(NativeFIFOInterface)
+@NativeFIFOInterface.din.setter
+@deprecated("instead of `fifo.din = x`, use `fifo.w_data = x`")
+def din(self, w_data):
+    self.w_data = w_data
+
+
+@extend(NativeFIFOInterface)
+@property
+@deprecated("instead of `fifo.writable`, use `fifo.w_rdy`")
+def writable(self):
+    return self.w_rdy
+
+
+@extend(NativeFIFOInterface)
+@NativeFIFOInterface.writable.setter
+@deprecated("instead of `fifo.writable = x`, use `fifo.w_rdy = x`")
+def writable(self, w_rdy):
+    self.w_rdy = w_rdy
+
+
+@extend(NativeFIFOInterface)
+@property
+@deprecated("instead of `fifo.we`, use `fifo.w_en`")
+def we(self):
+    return self.w_en
+
+
+@extend(NativeFIFOInterface)
+@NativeFIFOInterface.we.setter
+@deprecated("instead of `fifo.we = x`, use `fifo.w_en = x`")
+def we(self, w_en):
+    self.w_en = w_en
+
+
+@extend(NativeFIFOInterface)
+@property
+@deprecated("instead of `fifo.dout`, use `fifo.r_data`")
+def dout(self):
+    return self.r_data
+
+
+@extend(NativeFIFOInterface)
+@NativeFIFOInterface.dout.setter
+@deprecated("instead of `fifo.dout = x`, use `fifo.r_data = x`")
+def dout(self, r_data):
+    self.r_data = r_data
+
+
+@extend(NativeFIFOInterface)
+@property
+@deprecated("instead of `fifo.readable`, use `fifo.r_rdy`")
+def readable(self):
+    return self.r_rdy
+
+
+@extend(NativeFIFOInterface)
+@NativeFIFOInterface.readable.setter
+@deprecated("instead of `fifo.readable = x`, use `fifo.r_rdy = x`")
+def readable(self, r_rdy):
+    self.r_rdy = r_rdy
+
+
+@extend(NativeFIFOInterface)
+@property
+@deprecated("instead of `fifo.re`, use `fifo.r_en`")
+def re(self):
+    return self.r_en
+
+
+@extend(NativeFIFOInterface)
+@NativeFIFOInterface.re.setter
+@deprecated("instead of `fifo.re = x`, use `fifo.r_en = x`")
+def re(self, r_en):
+    self.r_en = r_en
+
+
 @extend(NativeFIFOInterface)
 def read(self):
     """Read method for simulation."""

nmigen/compat/genlib/fsm.py

@@ -3,8 +3,9 @@ from collections import OrderedDict
 from ..._utils import deprecated, _ignore_deprecated
 from ...hdl.xfrm import ValueTransformer, StatementTransformer
 from ...hdl.ast import *
+from ...hdl.ast import Signal as NativeSignal
 from ..fhdl.module import CompatModule, CompatFinalizeError
-from ..fhdl.structure import If, Case
+from ..fhdl.structure import Signal, If, Case
 
 
 __all__ = ["AnonymousState", "NextState", "NextValue", "FSM"]
@@ -33,7 +34,7 @@ def _target_eq(a, b):
     ty = type(a)
     if ty == Const:
         return a.value == b.value
-    elif ty == Signal:
+    elif ty == NativeSignal or ty == Signal:
         return a is b
     elif ty == Cat:
         return all(_target_eq(x, y) for x, y in zip(a.l, b.l))
@@ -164,7 +165,7 @@ class FSM(CompatModule):
         self.decoding = {n: s for s, n in self.encoding.items()}
 
         decoder = lambda n: "{}/{}".format(self.decoding[n], n)
-        self.state = Signal(max=nstates, reset=self.encoding[self.reset_state], decoder=decoder)
+        self.state = Signal(range(nstates), reset=self.encoding[self.reset_state], decoder=decoder)
         self.next_state = Signal.like(self.state)
 
         for state, signal in self.before_leaving_signals.items():