Add restrictions to collection methods. Fixes #1764. Fixes #988

spec/std/hash_spec.cr

@@ -710,7 +710,6 @@ describe "Hash" do
 
   describe "select!" do
     assert { {:a => 2, :b => 3}.select!(:b, :d).should eq({:b => 3}) }
-    assert { {:a => 2, :b => 3}.select!.should eq({} of Symbol => Int32) }
     assert { {:a => 2, :b => 3}.select!(:b, :a).should eq({:a => 2, :b => 3}) }
     assert { {:a => 2, :b => 3}.select!([:b, :a]).should eq({:a => 2, :b => 3}) }
     it "does change currrent hash" do

spec/std/set_spec.cr

@@ -123,9 +123,9 @@ describe "Set" do
 
   it "does |" do
     set1 = Set{1, 2, 3}
-    set2 = Set{4, 2, 5, "3"}
+    set2 = Set{4, 2, 5, 9}
     set3 = set1 | set2
-    set3.should eq(Set{1, 2, 3, 4, 5, "3"})
+    set3.should eq(Set{1, 2, 3, 4, 5, 9})
   end
 
   it "does -" do
@@ -135,125 +135,41 @@ describe "Set" do
     set3.should eq(Set{1, 3, 5})
   end
 
-  it "does -" do
-    set1 = Set{1, 2, 3, 4, 5}
-    set2 = Set{2, 4, 'a'}
-    set3 = set1 - set2
-    set3.should eq(Set{1, 3, 5})
-  end
-
-  it "does -" do
-    set1 = Set{1, 2, 3, 4, 'b'}
-    set2 = Set{2, 4, 5}
-    set3 = set1 - set2
-    set3.should eq(Set{1, 3, 'b'})
-  end
-
   it "does -" do
     set1 = Set{1, 2, 3, 4, 5}
     set2 = [2, 4, 6]
     set3 = set1 - set2
     set3.should eq(Set{1, 3, 5})
   end
 
-  it "does -" do
-    set1 = Set{1, 2, 3, 4, 5}
-    set2 = [2, 4, 'a']
-    set3 = set1 - set2
-    set3.should eq(Set{1, 3, 5})
-  end
-
-  it "does -" do
-    set1 = Set{1, 2, 3, 4, 'b'}
-    set2 = [2, 4, 5]
-    set3 = set1 - set2
-    set3.should eq(Set{1, 3, 'b'})
-  end
-
   it "does ^" do
     set1 = Set{1, 2, 3, 4, 5}
     set2 = Set{2, 4, 6}
     set3 = set1 ^ set2
     set3.should eq(Set{1, 3, 5, 6})
   end
 
-  it "does ^" do
-    set1 = Set{1, 2, 3, 4, 5}
-    set2 = Set{2, 4, 'a'}
-    set3 = set1 ^ set2
-    set3.should eq(Set{1, 3, 5, 'a'})
-  end
-
-  it "does ^" do
-    set1 = Set{1, 2, 3, 4, 'b'}
-    set2 = Set{2, 4, 5}
-    set3 = set1 ^ set2
-    set3.should eq(Set{1, 3, 5, 'b'})
-  end
-
   it "does ^" do
     set1 = Set{1, 2, 3, 4, 5}
     set2 = [2, 4, 6]
     set3 = set1 ^ set2
     set3.should eq(Set{1, 3, 5, 6})
   end
 
-  it "does ^" do
-    set1 = Set{1, 2, 3, 4, 5}
-    set2 = [2, 4, 'a']
-    set3 = set1 ^ set2
-    set3.should eq(Set{1, 3, 5, 'a'})
-  end
-
-  it "does ^" do
-    set1 = Set{1, 2, 3, 4, 'b'}
-    set2 = [2, 4, 5]
-    set3 = set1 ^ set2
-    set3.should eq(Set{1, 3, 5, 'b'})
-  end
-
   it "does subtract" do
     set1 = Set{1, 2, 3, 4, 5}
     set2 = Set{2, 4, 6}
     set1.subtract set2
     set1.should eq(Set{1, 3, 5})
   end
 
-  it "does subtract" do
-    set1 = Set{1, 2, 3, 4, 5}
-    set2 = Set{2, 4, 'a'}
-    set1.subtract set2
-    set1.should eq(Set{1, 3, 5})
-  end
-
-  it "does subtract" do
-    set1 = Set{1, 2, 3, 4, 'b'}
-    set2 = Set{2, 4, 5}
-    set1.subtract set2
-    set1.should eq(Set{1, 3, 'b'})
-  end
-
   it "does subtract" do
     set1 = Set{1, 2, 3, 4, 5}
     set2 = [2, 4, 6]
     set1.subtract set2
     set1.should eq(Set{1, 3, 5})
   end
 
-  it "does subtract" do
-    set1 = Set{1, 2, 3, 4, 5}
-    set2 = [2, 4, 'a']
-    set1.subtract set2
-    set1.should eq(Set{1, 3, 5})
-  end
-
-  it "does subtract" do
-    set1 = Set{1, 2, 3, 4, 'b'}
-    set2 = [2, 4, 5]
-    set1.subtract set2
-    set1.should eq(Set{1, 3, 'b'})
-  end
-
   it "does to_a" do
     Set{1, 2, 3}.to_a.should eq([1, 2, 3])
   end
@@ -311,7 +227,6 @@ describe "Set" do
     empty_set = Set(Int32).new
 
     set.subset?(Set{1, 2, 3, 4}).should be_true
-    set.subset?(Set{1, 2, 3, "4"}).should be_true
     set.subset?(Set{1, 2, 3}).should be_true
     set.subset?(Set{1, 2}).should be_false
     set.subset?(empty_set).should be_false
@@ -325,7 +240,6 @@ describe "Set" do
     empty_set = Set(Int32).new
 
     set.proper_subset?(Set{1, 2, 3, 4}).should be_true
-    set.proper_subset?(Set{1, 2, 3, "4"}).should be_true
     set.proper_subset?(Set{1, 2, 3}).should be_false
     set.proper_subset?(Set{1, 2}).should be_false
     set.proper_subset?(empty_set).should be_false
@@ -335,12 +249,11 @@ describe "Set" do
   end
 
   it "check superset" do
-    set = Set{1, 2, "3"}
+    set = Set{1, 2, 33}
     empty_set = Set(Int32).new
 
     set.superset?(empty_set).should be_true
     set.superset?(Set{1, 2}).should be_true
-    set.superset?(Set{1, 2, "3"}).should be_true
     set.superset?(Set{1, 2, 3}).should be_false
     set.superset?(Set{1, 2, 3, 4}).should be_false
     set.superset?(Set{1, 4}).should be_false
@@ -349,12 +262,11 @@ describe "Set" do
   end
 
   it "check proper_superset" do
-    set = Set{1, 2, "3"}
+    set = Set{1, 2, 33}
     empty_set = Set(Int32).new
 
     set.proper_superset?(empty_set).should be_true
     set.proper_superset?(Set{1, 2}).should be_true
-    set.proper_superset?(Set{1, 2, "3"}).should be_false
     set.proper_superset?(Set{1, 2, 3}).should be_false
     set.proper_superset?(Set{1, 2, 3, 4}).should be_false
     set.proper_superset?(Set{1, 4}).should be_false

src/array.cr

@@ -200,7 +200,7 @@ class Array(T)
   # ```
   #
   # See also: `#uniq`.
-  def &(other : Array(U))
+  def &(other : Array(T))
     return Array(T).new if self.empty? || other.empty?
 
     hash = other.to_lookup_hash
@@ -272,7 +272,7 @@ class Array(T)
   # ```
   # [1, 2, 3] - [2, 1] # => [3]
   # ```
-  def -(other : Array(U))
+  def -(other : Array(T))
     ary = Array(T).new(Math.max(size - other.size, 0))
     hash = other.to_lookup_hash
     each do |obj|
@@ -663,7 +663,16 @@ class Array(T)
   # ary # => ["a", "b", "c"]
   # ```
   def compact!
-    delete nil
+    found = false
+    reject! do |obj|
+      if obj.nil?
+        found = true
+        true
+      else
+        false
+      end
+    end
+    found
   end
 
   # Appends the elements of *other* to `self`, and returns `self`.
@@ -715,7 +724,7 @@ class Array(T)
   # a.delete("b")
   # a # => ["a", "c"]
   # ```
-  def delete(obj)
+  def delete(obj : T)
     reject! { |e| e == obj } != nil
   end
 
@@ -1615,7 +1624,7 @@ class Array(T)
     ReverseIterator.new(self)
   end
 
-  def rindex(value)
+  def rindex(value : T)
     rindex { |elem| elem == value }
   end
 

src/compiler/crystal/command.cr

@@ -613,7 +613,7 @@ class Crystal::Command
 
     output_filename ||= original_output_filename
     output_format ||= "text"
-    if !["text", "json"].includes?(output_format)
+    unless {"text", "json"}.includes?(output_format.not_nil!)
       error "You have input an invalid format, only text and JSON are supported"
     end
 

src/compiler/crystal/syntax/parser.cr

@@ -3168,7 +3168,8 @@ module Crystal
     end
 
     def check_valid_def_name
-      if {:is_a?, :as, :as?, :responds_to?, :nil?}.includes?(@token.value)
+      value = @token.value
+      if value.is_a?(Symbol) && {:is_a?, :as, :as?, :responds_to?, :nil?}.includes?(value)
         raise "'#{@token.value}' is a pseudo-method and can't be redefined", @token
       end
     end

src/deque.cr

@@ -216,7 +216,7 @@ class Deque(T)
   # a.delete("b")
   # a # => Deque{"a", "c"}
   # ```
-  def delete(obj)
+  def delete(obj : T)
     found = false
     i = 0
     while i < @size

src/enumerable.cr

@@ -104,7 +104,7 @@ module Enumerable(T)
   #
   #     [1, 2, 3, 4].count(3)  #=> 1
   #
-  def count(item)
+  def count(item : T)
     count { |e| e == item }
   end
 
@@ -327,7 +327,7 @@ module Enumerable(T)
   #     [1, 2, 3].includes?(2)  #=> true
   #     [1, 2, 3].includes?(5)  #=> false
   #
-  def includes?(obj)
+  def includes?(obj : T)
     any? { |e| e == obj }
   end
 
@@ -348,7 +348,7 @@ module Enumerable(T)
   #     ["Alice", "Bob"].index("Alice")  #=> 0
   #
   # Returns `nil` if *obj* is not in the collection.
-  def index(obj)
+  def index(obj : T)
     index { |e| e == obj }
   end