diff --git a/lib/linguist/heuristics.rb b/lib/linguist/heuristics.rb
index c2aaff0c..ab326cd1 100644
--- a/lib/linguist/heuristics.rb
+++ b/lib/linguist/heuristics.rb
@@ -14,25 +14,25 @@ module Linguist
     def self.find_by_heuristics(data, languages)
       if active?
         if languages.all? { |l| ["Perl", "Prolog"].include?(l) }
-          result = disambiguate_pl(data, languages)
+          result = disambiguate_pl(data)
         end
         if languages.all? { |l| ["ECL", "Prolog"].include?(l) }
-          result = disambiguate_ecl(data, languages)
+          result = disambiguate_ecl(data)
         end
         if languages.all? { |l| ["IDL", "Prolog"].include?(l) }
-          result = disambiguate_pro(data, languages)
+          result = disambiguate_pro(data)
         end
         if languages.all? { |l| ["Common Lisp", "OpenCL"].include?(l) }
-          result = disambiguate_cl(data, languages)
+          result = disambiguate_cl(data)
         end
         if languages.all? { |l| ["Hack", "PHP"].include?(l) }
-          result = disambiguate_hack(data, languages)
+          result = disambiguate_hack(data)
         end
         if languages.all? { |l| ["Scala", "SuperCollider"].include?(l) }
-          result = disambiguate_sc(data, languages)
+          result = disambiguate_sc(data)
         end
         if languages.all? { |l| ["AsciiDoc", "AGS Script"].include?(l) }
-          result = disambiguate_asc(data, languages)
+          result = disambiguate_asc(data)
         end
         return result
       end
@@ -42,7 +42,7 @@ module Linguist
     # We want to shortcut look for Objective-C _and_ now C++ too!
     #
     # Returns an array of Languages or []
-    def self.disambiguate_c(data, languages)
+    def self.disambiguate_c(data)
       matches = []
       if data.include?("@interface")
         matches << Language["Objective-C"]
@@ -52,7 +52,7 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_pl(data, languages)
+    def self.disambiguate_pl(data)
       matches = []
       if data.include?("use strict")
         matches << Language["Perl"]
@@ -62,7 +62,7 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_ecl(data, languages)
+    def self.disambiguate_ecl(data)
       matches = []
       if data.include?(":-")
         matches << Language["Prolog"]
@@ -72,7 +72,7 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_pro(data, languages)
+    def self.disambiguate_pro(data)
       matches = []
       if (data.include?(":-"))
         matches << Language["Prolog"]
@@ -82,7 +82,7 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_ts(data, languages)
+    def self.disambiguate_ts(data)
       matches = []
       if (data.include?("</translation>"))
         matches << Language["XML"]
@@ -92,7 +92,7 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_cl(data, languages)
+    def self.disambiguate_cl(data)
       matches = []
       if data.include?("(defun ")
         matches << Language["Common Lisp"]
@@ -102,14 +102,14 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_r(data, languages)
+    def self.disambiguate_r(data)
       matches = []
       matches << Language["Rebol"] if /\bRebol\b/i.match(data)
       matches << Language["R"] if data.include?("<-")
       matches
     end
 
-    def self.disambiguate_hack(data, languages)
+    def self.disambiguate_hack(data)
       matches = []
       if data.include?("<?hh")
         matches << Language["Hack"]
@@ -119,7 +119,7 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_sc(data, languages)
+    def self.disambiguate_sc(data)
       matches = []
       if (/\^(this|super)\./.match(data) || /^\s*(\+|\*)\s*\w+\s*{/.match(data) || /^\s*~\w+\s*=\./.match(data))
         matches << Language["SuperCollider"]
@@ -130,7 +130,7 @@ module Linguist
       matches
     end
 
-    def self.disambiguate_asc(data, languages)
+    def self.disambiguate_asc(data)
       matches = []
       matches << Language["AsciiDoc"] if /^=+(\s|\n)/.match(data)
       matches
diff --git a/test/test_heuristics.rb b/test/test_heuristics.rb
index e75fb470..1ed869fb 100644
--- a/test/test_heuristics.rb
+++ b/test/test_heuristics.rb
@@ -21,17 +21,17 @@ class TestHeuristcs < Test::Unit::TestCase
   end
 
   def test_obj_c_by_heuristics
-    languages = ["C++", "Objective-C"]
+    # languages = ["C++", "Objective-C"]
     # Only calling out '.h' filenames as these are the ones causing issues
     all_fixtures("Objective-C", "*.h").each do |fixture|
-      results = Heuristics.disambiguate_c(fixture("Objective-C/#{File.basename(fixture)}"), languages)
+      results = Heuristics.disambiguate_c(fixture("Objective-C/#{File.basename(fixture)}"))
       assert_equal Language["Objective-C"], results.first
     end
   end
 
   def test_cpp_by_heuristics
-    languages = ["C++", "Objective-C"]
-    results = Heuristics.disambiguate_c(fixture("C++/render_adapter.cpp"), languages)
+    # languages = ["C++", "Objective-C"]
+    results = Heuristics.disambiguate_c(fixture("C++/render_adapter.cpp"))
     assert_equal Language["C++"], results.first
   end
 
@@ -42,56 +42,56 @@ class TestHeuristcs < Test::Unit::TestCase
   end
 
   def test_pl_prolog_by_heuristics
-    languages = ["Perl", "Prolog"]
-    results = Heuristics.disambiguate_pl(fixture("Prolog/turing.pl"), languages)
+    # languages = ["Perl", "Prolog"]
+    results = Heuristics.disambiguate_pl(fixture("Prolog/turing.pl"))
     assert_equal Language["Prolog"], results.first
   end
 
   def test_pl_perl_by_heuristics
-    languages = ["Perl", "Prolog"]
-    results = Heuristics.disambiguate_pl(fixture("Perl/perl-test.t"), languages)
+    # languages = ["Perl", "Prolog"]
+    results = Heuristics.disambiguate_pl(fixture("Perl/perl-test.t"))
     assert_equal Language["Perl"], results.first
   end
 
   def test_ecl_prolog_by_heuristics
-    languages = ["ECL", "Prolog"]
-    results = Heuristics.disambiguate_ecl(fixture("Prolog/or-constraint.ecl"), languages)
+    # languages = ["ECL", "Prolog"]
+    results = Heuristics.disambiguate_ecl(fixture("Prolog/or-constraint.ecl"))
     assert_equal Language["Prolog"], results.first
   end
 
   def test_ecl_ecl_by_heuristics
-    languages = ["ECL", "Prolog"]
-    results = Heuristics.disambiguate_ecl(fixture("ECL/sample.ecl"), languages)
+    # languages = ["ECL", "Prolog"]
+    results = Heuristics.disambiguate_ecl(fixture("ECL/sample.ecl"))
     assert_equal Language["ECL"], results.first
   end
 
   def test_pro_prolog_by_heuristics
-    languages = ["IDL", "Prolog"]
-    results = Heuristics.disambiguate_pro(fixture("Prolog/logic-problem.pro"), languages)
+    # languages = ["IDL", "Prolog"]
+    results = Heuristics.disambiguate_pro(fixture("Prolog/logic-problem.pro"))
     assert_equal Language["Prolog"], results.first
   end
 
   def test_pro_idl_by_heuristics
-    languages = ["IDL", "Prolog"]
-    results = Heuristics.disambiguate_pro(fixture("IDL/mg_acosh.pro"), languages)
+    # languages = ["IDL", "Prolog"]
+    results = Heuristics.disambiguate_pro(fixture("IDL/mg_acosh.pro"))
     assert_equal Language["IDL"], results.first
   end
 
   def test_asc_asciidoc_by_heuristics
-    languages = ["AGS Script", "AsciiDoc"]
-    results = Heuristics.disambiguate_asc(fixture("AsciiDoc/list.asc"), languages)
+    # languages = ["AGS Script", "AsciiDoc"]
+    results = Heuristics.disambiguate_asc(fixture("AsciiDoc/list.asc"))
     assert_equal Language["AsciiDoc"], results.first
   end
 
   def test_ts_typescript_by_heuristics
-    languages = ["TypeScript", "XML"]
-    results = Heuristics.disambiguate_ts(fixture("TypeScript/classes.ts"), languages)
+    # languages = ["TypeScript", "XML"]
+    results = Heuristics.disambiguate_ts(fixture("TypeScript/classes.ts"))
     assert_equal Language["TypeScript"], results.first
   end
 
   def test_ts_xml_by_heuristics
-    languages = ["TypeScript", "XML"]
-    results = Heuristics.disambiguate_ts(fixture("XML/pt_BR.xml"), languages)
+    # languages = ["TypeScript", "XML"]
+    results = Heuristics.disambiguate_ts(fixture("XML/pt_BR.xml"))
     assert_equal Language["XML"], results.first
   end
 
@@ -99,27 +99,27 @@ class TestHeuristcs < Test::Unit::TestCase
     languages = ["Common Lisp", "OpenCL"]
     languages.each do |language|
       all_fixtures(language).each do |fixture|
-        results = Heuristics.disambiguate_cl(fixture("#{language}/#{File.basename(fixture)}"), languages)
+        results = Heuristics.disambiguate_cl(fixture("#{language}/#{File.basename(fixture)}"))
         assert_equal Language[language], results.first
       end
     end
   end
 
   def test_hack_by_heuristics
-    languages = ["Hack", "PHP"]
-    results = Heuristics.disambiguate_hack(fixture("Hack/funs.php"), languages)
+    # languages = ["Hack", "PHP"]
+    results = Heuristics.disambiguate_hack(fixture("Hack/funs.php"))
     assert_equal Language["Hack"], results.first
   end
 
   def test_sc_supercollider_by_heuristics
-    languages = ["Scala", "SuperCollider"]
-    results = Heuristics.disambiguate_sc(fixture("SuperCollider/WarpPreset.sc"), languages)
+    # languages = ["Scala", "SuperCollider"]
+    results = Heuristics.disambiguate_sc(fixture("SuperCollider/WarpPreset.sc"))
     assert_equal Language["SuperCollider"], results.first
   end
 
   def test_sc_scala_by_heuristics
-    languages = ["Scala", "SuperCollider"]
-    results = Heuristics.disambiguate_sc(fixture("Scala/node11.sc"), languages)
+    # languages = ["Scala", "SuperCollider"]
+    results = Heuristics.disambiguate_sc(fixture("Scala/node11.sc"))
     assert_equal Language["Scala"], results.first
   end
 end