Typecheck default values if unusued

[pkorotkov]

This code triggers an expected error

class A(T)
  getter values

  def initialize(@values : Array(T) = Int)
  end
end

a = A(String).new

p typeof(a.values)

#link 1

but the following snippet compiles and runs just fine contrary to my expectations

class A(T)
  getter values

  def initialize(@values : Array(T) = Int)
  end
end

a = A.new(values = ["One", "Two"])

p typeof(a.values)

#link 2

[jhass]

Reduced

class A
  def initialize(@value : Int32 = true)
  end
end

a = A.new

vs

class A
  def initialize(@value : Int32 = true)
  end
end

a = A.new(1)

[asterite]

Not sure this is a bug. Right now you can do:

# You can only pass a String, but the default value is nil
def foo(value : String = nil)
end

foo # OK
foo "hello" # OK
foo nil # Error

In that way you can restrict an argument to a type but use a default value of another type.

[jhass]

That's just even more inconsistent, isn't it? Whether it errors depending on the type of variable that's restricted. We decided to conflate restriction and declaration for instance variables there, we should keep the rest of the language consistent to it.

Also I don't really see a real usecase behind your example tbh.

[asterite]

I was thinking about having nil there to know that a value that's not possible to pass was received in the method, so you know no argument has been passed. This could also be useful if you use the null object pattern. But yeah, it's probably inconsistent. I'll try to fix this, though the error will happen if you invoke the method without arguments, so the second snippet in the first comment will still compile fine (so the end result will be more or less the one we have right now)

[bcardiff]

IMO it is a bug. It will force to implementor some T? for nillable arguments but I think is the right thing to do.

Maybe there will be a tricky part when the method involves type variables. I was trying some snippets but might reach a separate issue here:

https://play.crystal-lang.org/#/r/zbd

def foo(o : K, h : Hash(K, V) = { "foo" => "bar" })
  h.keys
end

pp foo(7, {1 => 2}) # => [1]
pp foo("sdf") # => ["foo"]
pp foo(8) # => ["foo"] 

[asterite]

Part of this was fixed in #3834

The original title of this issue is "Typecheck default values if unusued", which basically means that this should give a compile error:

def foo(x : Int32 = "hello")
end

That is, it should give a compile error even if we don't invoke foo. I'm not sure about that. Right now we only type-check things on invocation. For example this works fine in Ruby:

def foo(x = unknown)
end

foo(1)

But if we don't pass an argument we get an error. Well, it's the same in Crystal here, and I think that's OK (having to type check all methods even if they are not used will slow down compilation, and I'm not sure it's even possible in all cases)