Fix typecheck error on atom negation with equivalent type

src/ast/transform/TypeChecker.cpp

@@ -383,10 +383,12 @@ void TypeCheckerImpl::visit_(type_identity<Atom>, const Atom& atom) {
             // Declared attribute and deduced type agree if:
             // They are the same type, or
             // They are derived from the same constant type.
+            // They are equivalent types.
             bool validAttribute = all_of(argTypes, [&](const analysis::Type& type) {
-                return type == attributeType || any_of(typeEnv.getConstantTypes(), [&](auto& constantType) {
-                    return isSubtypeOf(attributeType, constantType) && isSubtypeOf(type, constantType);
-                });
+                return type == attributeType || areEquivalentTypes(type, attributeType) ||
+                       any_of(typeEnv.getConstantTypes(), [&](auto& constantType) {
+                           return isSubtypeOf(attributeType, constantType) && isSubtypeOf(type, constantType);
+                       });
             });
 
             if (!validAttribute) {

tests/syntactic/CMakeLists.txt

@@ -66,6 +66,7 @@ positive_test(dot_identifiers)
 positive_test(input_adt_names1)
 positive_test(input_adt_names2)
 positive_test(input_directive_rfc4180)
+positive_test(equivalent_types_in_negation)
 if (NOT MSVC)
 # does not pass with Visual Studio pre-processor because it preserves all whitespaces
 positive_test(whitespaces)

tests/syntactic/equivalent_types_in_negation/equivalent_types_in_negation.dl

@@ -0,0 +1,26 @@
+.type List = [name: symbol, rest: List]
+.decl list_decl(l:List)
+list_decl(["A", ["B", ["C", nil]]]).
+list_decl(["D", ["E", ["F", nil]]]).
+
+.type Alias = List
+
+.decl flatten_list(l:List)
+flatten_list(l) :- list_decl(l).
+flatten_list(l) :- flatten_list([_, l]).
+
+.decl alias_map(a: Alias, l:List)
+alias_map(l, l) :-
+    flatten_list(l).
+
+.decl alias(a: Alias)
+alias(a) :- alias_map(a, _).
+
+.decl parent(a: Alias, p: Alias)
+parent(a, p) :-
+    alias_map(a, [_, parent]),
+    alias_map(p, parent).
+
+.decl has_no_parent(a: Alias)
+has_no_parent(a) :-
+    alias(a), !parent(a, _).   // No more error here