Fix missing implementation for identity comparison of structs.

Prior to this commit, trying to compare two structs for
identity equality (`===`/`!==`) would raise an exception
at compile time, because this case was not implemented.

There are still other cases that are not implemented
(such as dealing with the case where one side is a boxed value,
and the other side is an unboxed value).
But those are left to be implemented at a later time.

Particularly, it's expected that we'll soon redesign the way
equality works in Savi (
see https://savi.zulipchat.com/#narrow/stream/294897-general/topic/Element-wise.20Array.20comparison.20fails
) so that the compiler will automatically generate
a default `==` implementation for all types
(which can be overridden by the user). At that time, we could
also generate a `===` implementation that cannot be overridden,
which would allow us to simplify the code being modified
here in this commit, as we could change this call site to
a basic method call (for the `===` method) after type comparison,
rather than coding the field-wise comparison as LLVM IR as
we did here, and sidestepping issues with boxed/unboxed things,
as the typical virtual call mechanism will take care of
resolving the appropriate unboxed values into method args.

Author: jemc

spec/language/semantics/identity_spec.savi

@@ -1,5 +1,7 @@
 :module IdentitySpec
   :fun run(test MicroTest)
+    test["string literal ==="].pass = "example" === "example"
+    test["string literal !=="].pass = "example" !== "differs"
     test["identity_digest_of string literal =="].pass =
       identity_digest_of "example" ==
       identity_digest_of "example"
@@ -9,6 +11,8 @@
 
     class_instance_a = Container(String).new("example")
     class_instance_b = Container(String).new("example")
+    test["class ==="].pass = class_instance_a === class_instance_a
+    test["class !=="].pass = class_instance_a !== class_instance_b
     test["identity_digest_of class !="].pass =
       identity_digest_of class_instance_a !=
       identity_digest_of class_instance_b
@@ -19,6 +23,8 @@
     struct_instance_a = ContainerStruct(String).new("example")
     struct_instance_b = ContainerStruct(String).new("example")
     struct_instance_c = ContainerStruct(String).new("differs")
+    test["struct ==="].pass = struct_instance_a === struct_instance_b
+    test["struct !=="].pass = struct_instance_a !== struct_instance_c
     test["identity_digest_of struct =="].pass =
       identity_digest_of struct_instance_a ==
       identity_digest_of struct_instance_b

src/savi/compiler/code_gen.cr

@@ -2182,11 +2182,25 @@ class Savi::Compiler::CodeGen
     old_value
   end
 
-  def gen_check_identity_is(relate : AST::Relate, positive_check : Bool)
-    lhs_type = type_of(relate.lhs)
-    rhs_type = type_of(relate.rhs)
-    lhs = gen_expr(relate.lhs)
-    rhs = gen_expr(relate.rhs)
+  def gen_check_identity_equal(relate : AST::Relate, positive_check : Bool)
+    gen_check_identity_equal_inner(
+      gen_expr(relate.lhs),
+      gen_expr(relate.rhs),
+      type_of(relate.lhs),
+      type_of(relate.rhs),
+      relate.pos,
+      positive_check,
+    )
+  end
+
+  def gen_check_identity_equal_inner(
+    lhs : LLVM::Value,
+    rhs : LLVM::Value,
+    lhs_type : Reach::Ref,
+    rhs_type : Reach::Ref,
+    pos : Source::Pos,
+    positive_check : Bool
+  )
     pred = positive_check ? LLVM::IntPredicate::EQ : LLVM::IntPredicate::NE
 
     # If the values are floating point values, they should be compared by their
@@ -2215,7 +2229,59 @@ class Savi::Compiler::CodeGen
         )
       else
         # Integers of different types never have the same identity.
-        gen_bool(false)
+        gen_bool(!positive_check)
+      end
+    elsif lhs.type.kind == LLVM::Type::Kind::Struct \
+      && rhs.type.kind == LLVM::Type::Kind::Struct
+      if lhs.type == rhs.type
+        # Structs of the same type are compared by field-wise comparison.
+        # TODO: This will eventually be generated by earlier stages of the
+        # compiler which will also be responsible for equality checks with `==`,
+        # which will have the same default semantics for structs as `===`,
+        # unless the user overrides a custom definition for `==`
+        # (but even in that case, we should have a standard definition of `===`)
+        phi_blocks = [] of LLVM::BasicBlock
+        phi_values = [] of LLVM::Value
+        post_block = gen_block("structs.identity.compare")
+        success_block = gen_block("structs.identity.compare.success")
+
+        last_compare = gen_bool(true) # with no fields, the comparison succeeds.
+        gtype = gtype_of(lhs_type)
+        gtype.fields.each_with_index { |(field_name, field_type), index|
+          next_block = gen_block("structs.identity.compare.#{field_name}")
+
+          phi_values << gen_bool(!positive_check)
+          phi_blocks << @builder.insert_block.not_nil!
+          @builder.cond(
+            last_compare,
+            positive_check ? next_block : post_block,
+            positive_check ? post_block : next_block
+          )
+
+          @builder.position_at_end(next_block)
+          last_compare = gen_check_identity_equal_inner(
+            @builder.extract_value(lhs, index, "#{lhs.name}.#{field_name}"),
+            @builder.extract_value(lhs, index, "#{rhs.name}.#{field_name}"),
+            field_type,
+            field_type,
+            pos,
+            positive_check,
+          )
+        }
+        phi_values << gen_bool(!positive_check)
+        phi_blocks << @builder.insert_block.not_nil!
+        @builder.cond(last_compare, success_block, post_block)
+
+        @builder.position_at_end(success_block)
+        phi_values << gen_bool(positive_check)
+        phi_blocks << @builder.insert_block.not_nil!
+        @builder.br(post_block)
+
+        @builder.position_at_end(post_block)
+        @builder.phi(@i1, phi_blocks, phi_values)
+      else
+        # Structs of different types never have the same identity.
+        gen_bool(!positive_check)
       end
     elsif (
       lhs_type == rhs_type || lhs.type == rhs.type || \
@@ -2232,7 +2298,7 @@ class Savi::Compiler::CodeGen
         "#{lhs.name}.is.#{rhs.name}",
       )
     else
-      raise NotImplementedError.new("this comparison:\n#{relate.pos.show}")
+      raise NotImplementedError.new("this comparison:\n#{pos.show}")
     end
   end
 
@@ -2626,8 +2692,8 @@ class Savi::Compiler::CodeGen
       case expr.op.as(AST::Operator).value
       when "=" then gen_eq(expr)
       when "<<=" then gen_displacing_eq(expr)
-      when "===" then gen_check_identity_is(expr, true)
-      when "!==" then gen_check_identity_is(expr, false)
+      when "===" then gen_check_identity_equal(expr, true)
+      when "!==" then gen_check_identity_equal(expr, false)
       when "<:" then gen_check_subtype(expr, true)
       when "!<:" then gen_check_subtype(expr, false)
       when "static_address_of_function" then gen_static_address_of_function(expr)