Better handle free vars and unknown types in abstract defs

spec/compiler/semantic/abstract_def_spec.cr

@@ -1152,4 +1152,263 @@ describe "Semantic: abstract def" do
         CRYSTAL
     end
   end
+
+  it "reports undefined constant error for undefined type in abstract method" do
+    assert_error <<-CRYSTAL, "undefined constant Unknown"
+      module Foo
+        abstract def foo(x : Unknown)
+      end
+
+      class Bar
+        include Foo
+
+        def foo(x : Int32)
+        end
+      end
+      CRYSTAL
+  end
+
+  it "reports undefined constant error for undefined type in implementing method" do
+    assert_error <<-CRYSTAL, "undefined constant Unknown"
+      module Foo
+        abstract def foo(x : Int32)
+      end
+
+      class Bar
+        include Foo
+
+        def foo(x : Unknown)
+        end
+      end
+      CRYSTAL
+  end
+
+  it "allows forall type parameters in abstract methods" do
+    assert_no_errors <<-CRYSTAL
+      module Foo
+        abstract def foo(x : U) : U forall U
+      end
+
+      class Bar
+        include Foo
+
+        def foo(x : U) : U forall U
+          x
+        end
+      end
+      CRYSTAL
+  end
+
+  it "allows generic type parameters from enclosing class" do
+    assert_no_errors <<-CRYSTAL
+      module Comparable(T)
+        abstract def <=>(other : T)
+      end
+
+      struct Slice(T)
+        include Comparable(Slice(T))
+
+        def <=>(other : Slice(T))
+          0
+        end
+      end
+      CRYSTAL
+  end
+
+  it "allows multiple generic type parameters" do
+    assert_no_errors <<-CRYSTAL
+      abstract class Container(K, V)
+        abstract def get(key : K) : V?
+        abstract def set(key : K, value : V) : Nil
+      end
+
+      class HashMap(K, V) < Container(K, V)
+        def get(key : K) : V?
+          nil
+        end
+
+        def set(key : K, value : V) : Nil
+        end
+      end
+      CRYSTAL
+  end
+
+  it "distinguishes between undefined types and valid type parameters" do
+    assert_error <<-CRYSTAL, "undefined constant UnknownType"
+      abstract class Container(T)
+        abstract def process(x : T, y : UnknownType)
+      end
+
+      class MyContainer(T) < Container(T)
+        def process(x : T, y : String)
+        end
+      end
+      CRYSTAL
+  end
+
+  it "reports undefined multi-segment paths" do
+    assert_error <<-CRYSTAL, "undefined constant Some::Path::Unknown"
+      module Foo
+        abstract def foo(x : Some::Path::Unknown)
+      end
+
+      class Bar
+        include Foo
+
+        def foo(x : Int32)
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts untyped parameter implementing forall abstract method with return type" do
+    assert_no_errors <<-CRYSTAL
+      module Interface
+        abstract def transform(value : T) : T forall T
+      end
+
+      class Implementation
+        include Interface
+
+        def transform(value)
+          value
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts untyped parameter implementing forall abstract method without return type" do
+    assert_no_errors <<-CRYSTAL
+      module Interface
+        abstract def transform(value : T) forall T
+      end
+
+      class Implementation
+        include Interface
+
+        def transform(value)
+          value
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts specific type implementing forall abstract method" do
+    assert_no_errors <<-CRYSTAL
+      module Interface
+        abstract def transform(type : T.class) : T forall T
+      end
+
+      class Implementation
+        include Interface
+
+        def transform(type : Int32.class) : Int32
+          123
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts more specific type implementing forall generic parameter" do
+    assert_no_errors <<-CRYSTAL
+      module Interface
+        abstract def transform(x : Array(T)) forall T
+      end
+
+      class Implementation
+        include Interface
+
+        def transform(x : Indexable) : Int32
+          123
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts generic method implementing generic abstract method with forall" do
+    assert_no_errors <<-CRYSTAL
+      module Interface
+        abstract def transform(type : T.class) : T forall T
+      end
+
+      class Implementation
+        include Interface
+
+        def transform(type : T.class) : T forall T
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts generic method when implementation has at least as many forall values than abstract" do
+    assert_no_errors <<-CRYSTAL
+      abstract class Foo
+        abstract def foo(x : T, y : Int32) forall T
+      end
+
+      class Bar < Foo
+        def foo(x : T, y : U) forall T, U; end
+      end
+      CRYSTAL
+  end
+
+  it "accepts matching forall parameters even with different names" do
+    assert_no_errors <<-CRYSTAL
+      module Interface
+        abstract def transform(value : T) : T forall T
+      end
+
+      class Implementation
+        include Interface
+
+        def transform(value : U) : U forall U
+          value
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts specific types implementing forall abstract method" do
+    assert_no_errors <<-CRYSTAL
+      abstract class Container
+        abstract def get(key : K) : V forall K, V
+      end
+
+      class MyContainer < Container
+        def get(key : String) : Int32
+          42
+        end
+      end
+      CRYSTAL
+  end
+
+  it "accepts non-generic implementation when abstract def has no forall" do
+    assert_no_errors <<-CRYSTAL
+      abstract class Base
+        abstract def process(x : Int32) : String
+      end
+
+      class Derived < Base
+        def process(x : Int32) : String
+          x.to_s
+        end
+      end
+      CRYSTAL
+  end
+
+  pending "errors when implementation uses incompatible type with forall abstract method" do
+    assert_error <<-CRYSTAL, "abstract `def Interface#transform(x : Array(T)) forall T` must be implemented"
+      module Interface
+        abstract def transform(x : Array(T)) forall T
+      end
+
+      class Implementation
+        include Interface
+
+        def transform(x : Int32) : Int32
+          123
+        end
+      end
+      CRYSTAL
+  end
 end

src/compiler/crystal/codegen/abi.cr

@@ -33,7 +33,7 @@ abstract class Crystal::ABI
     end
   end
 
-  abstract def abi_info(atys : Array(LLVM::Type), rty : LLVM::Type, ret_def : Bool, context : Context)
+  abstract def abi_info(atys : Array(LLVM::Type), rty : LLVM::Type, ret_def : Bool, context : LLVM::Context)
   abstract def size(type : LLVM::Type)
   abstract def align(type : LLVM::Type)
 

src/compiler/crystal/semantic/abstract_def_checker.cr

@@ -116,7 +116,7 @@ class Crystal::AbstractDefChecker
 
         if implements?(target_type, ancestor_type, a_def, def_free_vars, base, method, method_free_vars)
           unless implemented
-            check_return_type(target_type, ancestor_type, a_def, base, method)
+            check_return_type(target_type, ancestor_type, a_def, def_free_vars, base, method, method_free_vars)
             implemented = true
           end
 
@@ -264,19 +264,66 @@ class Crystal::AbstractDefChecker
     return false if r1 && !r2
     if r2 && r1 && r1 != r2
       # Check if a1.restriction is contravariant with a2.restriction
+      rt1 = nil
+      rt2 = nil
+
       begin
         rt1 = t1.lookup_type(r1, free_vars: free_vars1)
+      rescue Crystal::TypeException
+      end
+
+      begin
         rt2 = t2.lookup_type(r2, free_vars: free_vars2)
-        return false unless rt2.implements?(rt1)
       rescue Crystal::TypeException
-        # Ignore if we can't find a type (assume the method is implemented)
-        return true
+      end
+
+      if rt1 && rt2
+        # Both types resolved - check compatibility
+        return false unless rt2.implements?(rt1)
+      elsif !rt2
+        # Only implementation side couldn't be resolved
+        if !can_lookup?(r2, free_vars2, t2)
+          report_undefined_type(r2)
+        end
+      elsif !rt1
+        # Only abstract side couldn't be resolved
+        if !can_lookup?(r1, free_vars1, t1)
+          report_undefined_type(r1)
+        end
       end
     end
 
     true
   end
 
+  # Check if a restriction can potentially be looked up (is a free var or might be resolved later)
+  private def can_lookup?(restriction : ASTNode, free_vars, type : Type? = nil) : Bool
+    return true unless restriction.is_a?(Path)
+
+    # For single-name paths, check if it's a free variable
+    if name = restriction.single_name?
+      # Check if it's in free_vars (forall parameters)
+      return true if free_vars && free_vars.has_key?(name)
+
+      # Check if it's a type parameter of the enclosing generic type
+      if type && type.is_a?(GenericType)
+        return true if type.type_vars.includes?(name)
+      end
+
+      return false
+    end
+
+    return true if restriction.global?
+
+    # Other multi-segment paths can't be free variables
+    # Return false to indicate they should be reported as undefined if lookup failed
+    false
+  end
+
+  private def report_undefined_type(restriction : ASTNode)
+    report_error(restriction, "undefined constant #{restriction}")
+  end
+
   def same_parameters?(m1 : Def, m2 : Def)
     return false unless m1.args.size == m2.args.size
 
@@ -318,12 +365,13 @@ class Crystal::AbstractDefChecker
 
   # Checks that the return type of `type#method` matches that of `base_type#base_method`
   # when computing that information for `target_type` (`type` is an ancestor of `target_type`).
-  def check_return_type(target_type : Type, type : Type, method : Def, base_type : Type, base_method : Def)
+  def check_return_type(target_type : Type, type : Type, method : Def, method_free_vars, base_type : Type, base_method : Def, base_method_free_vars)
     base_return_type_node = base_method.return_type
     return unless base_return_type_node
 
-    original_base_return_type = base_type.lookup_type?(base_return_type_node)
+    original_base_return_type = base_type.lookup_type?(base_return_type_node, free_vars: base_method_free_vars)
     unless original_base_return_type
+      return if can_lookup?(base_return_type_node, base_method_free_vars, base_type)
       report_error(base_return_type_node, "can't resolve return type #{base_return_type_node}")
       return
     end
@@ -340,8 +388,9 @@ class Crystal::AbstractDefChecker
       base_return_type_node.accept(replacer)
     end
 
-    base_return_type = base_type.lookup_type?(base_return_type_node)
+    base_return_type = base_type.lookup_type?(base_return_type_node, free_vars: base_method_free_vars)
     unless base_return_type
+      return if can_lookup?(base_return_type_node, base_method_free_vars, base_type)
       report_error(base_return_type_node, "can't resolve return type #{base_return_type_node}")
       return
     end
@@ -352,8 +401,9 @@ class Crystal::AbstractDefChecker
       return
     end
 
-    return_type = type.lookup_type?(return_type_node)
+    return_type = type.lookup_type?(return_type_node, free_vars: method_free_vars)
     unless return_type
+      return if can_lookup?(return_type_node, method_free_vars, type)
       report_error(return_type_node, "can't resolve return type #{return_type_node}")
       return
     end