Avoid Module creation for Constant Gate scenarios

lib/src/signals/logic.dart

@@ -319,13 +319,59 @@ class Logic {
   void operator <=(Logic other) => gets(other);
 
   /// Logical bitwise NOT.
-  Logic operator ~() => NotGate(this).out;
+  Logic operator ~() {
+    if (this is Const) {
+      if (value.isValid) {
+        if (value == LogicValue.of(0, width: width)) {
+          return Const(LogicValue.filled(width, LogicValue.one));
+        } else if (value == LogicValue.filled(width, LogicValue.one)) {
+          return Const(LogicValue.of(0, width: width));
+        }
+      } else {
+        return Const(LogicValue.x, width: width);
+      }
+    }
+    return NotGate(this).out;
+  }
 
   /// Logical bitwise AND.
-  Logic operator &(Logic other) => And2Gate(this, other).out;
+  Logic operator &(Logic other) {
+    if (this is Const || other is Const) {
+      if (value.isValid && other.value.isValid) {
+        if (value == LogicValue.of(0, width: width) ||
+            other.value == LogicValue.of(0, width: width)) {
+          return Const(LogicValue.of(0, width: width));
+        } else if (value == LogicValue.filled(width, LogicValue.one)) {
+          return other;
+        } else if (other.value == LogicValue.filled(width, LogicValue.one)) {
+          return this;
+        }
+      } else {
+        return Const(LogicValue.x, width: width);
+      }
+    }
+    return And2Gate(this, other).out;
+  }
 
   /// Logical bitwise OR.
-  Logic operator |(Logic other) => Or2Gate(this, other).out;
+  Logic operator |(Logic other) {
+    if (this is Const || other is Const) {
+      if (value.isValid && other.value.isValid) {
+        if (value == LogicValue.filled(width, LogicValue.one) ||
+            other.value == LogicValue.filled(width, LogicValue.one)) {
+          return Const(LogicValue.filled(width, LogicValue.one));
+        } else if (value == LogicValue.of(LogicValue.zero, width: width)) {
+          return other;
+        } else if (other.value ==
+            LogicValue.of(LogicValue.zero, width: width)) {
+          return this;
+        }
+      } else {
+        return Const(LogicValue.x, width: width);
+      }
+    }
+    return Or2Gate(this, other).out;
+  }
 
   /// Logical bitwise XOR.
   Logic operator ^(Logic other) => Xor2Gate(this, other).out;

test/gate_test.dart

@@ -353,6 +353,109 @@ void main() {
     });
   });
 
+  group('Const input Gate test', () {
+    test('NotGate single bit Constant input', () async {
+      final a = Logic();
+      final b = Const(LogicValue.zero, width: 1);
+      final c = Const(LogicValue.x, width: 1);
+      final d = Const(LogicValue.one, width: 1);
+      a.put(LogicValue.one);
+
+      final result = ~b;
+      expect(result, isA<Const>());
+      expect(result.value, equals(LogicValue.one));
+
+      final result2 = ~c;
+      expect(result2, isA<Const>());
+      expect(result2.value, equals(LogicValue.x));
+
+      final result3 = ~d;
+      expect(result3, isA<Const>());
+      expect(result3.value, equals(LogicValue.zero));
+    });
+
+    test('NotGate Multi bit Constant input', () async {
+      final b = Const(bin('1111'), width: 4);
+      final c = Const(bin('0100'), width: 4);
+      final result = ~b;
+
+      expect(result, isA<Const>());
+      expect(result.value, equals(LogicValue.of(LogicValue.zero, width: 4)));
+
+      final result2 = ~c;
+      expect(result2, isA<Logic>());
+      expect(result2.value, equals(LogicValue.of(11, width: 4)));
+    });
+
+    test('And2Gate Single bit Constant input', () async {
+      final a = Logic();
+      final b = Const(LogicValue.zero, width: 1);
+      final c = Const(LogicValue.x, width: 1);
+      final d = Const(LogicValue.one, width: 1);
+      a.put(LogicValue.one);
+
+      final result = a & b;
+      expect(result, isA<Const>());
+      expect(result.value, equals(LogicValue.zero));
+
+      final result2 = a & c;
+      expect(result2, isA<Const>());
+      expect(result2.value, equals(LogicValue.x));
+
+      final result3 = a & d;
+      expect(result3, isA<Logic>());
+      expect(result3.value, equals(a.value));
+    });
+
+    test('And2Gate Multi bit Constant input', () async {
+      final a = Const(LogicValue.of(LogicValue.zero, width: 4));
+      final b = Const(bin('1111'), width: 4);
+      final c = Const(bin('0100'), width: 4);
+      final result = a & c;
+
+      expect(result, isA<Const>());
+      expect(result.value, equals(LogicValue.of(LogicValue.zero, width: 4)));
+
+      final result2 = b & c;
+      expect(result2, isA<Logic>());
+      expect(result2.value, equals(c.value));
+    });
+
+    test('OR2Gate Single bit Constant input', () async {
+      final a = Logic();
+      final b = Const(LogicValue.zero, width: 1);
+      final c = Const(LogicValue.x, width: 1);
+      final d = Const(LogicValue.one, width: 1);
+      a.put(LogicValue.one);
+
+      final result = a | b;
+      expect(result, isA<Logic>());
+      expect(result.value, equals(a.value));
+
+      final result2 = a | c;
+      expect(result2, isA<Const>());
+      expect(result2.value, equals(LogicValue.x));
+
+      final result3 = a | d;
+      expect(result3, isA<Const>());
+      expect(result3.value, equals(LogicValue.one));
+    });
+
+    test('OR2Gate Multi bit Constant input', () async {
+      final a = Const(LogicValue.of(LogicValue.zero, width: 4));
+      final b = Const(bin('1111'), width: 4);
+      final c = Const(bin('0100'), width: 4);
+      final result = a | c;
+
+      expect(result, isA<Logic>());
+      expect(result.value, equals(c.value));
+
+      final result2 = b | c;
+      expect(result2, isA<Const>());
+      expect(result2.value, equals(LogicValue.filled(4, LogicValue.one)));
+    });
+  });
+
   group('simcompare', () {
     test('NotGate single bit', () async {
       final gtm = GateTestModule(Logic(), Logic());