Fix "Fix ccall with no supplied varargs" (JuliaLang/JuliaLowering.jl#118)

Author: mlechu

JuliaLowering/src/desugaring.jl

@@ -1706,6 +1706,16 @@ function expand_kw_call(ctx, srcref, farg, args, kws)
     ]
 end
 
+# Special rule: Any becomes core.Any regardless of the module
+# scope, and don't need GC roots.
+function expand_ccall_argtype(ctx, ex)
+    if is_same_identifier_like(ex, "Any")
+        @ast ctx ex "Any"::K"core"
+    else
+        expand_forms_2(ctx, ex)
+    end
+end
+
 # Expand the (sym,lib) argument to ccall/cglobal
 function expand_C_library_symbol(ctx, ex)
     expanded = expand_forms_2(ctx, ex)
@@ -1749,44 +1759,36 @@ function expand_ccall(ctx, ex)
     end
     arg_types = children(arg_type_tuple)
     vararg_type = nothing
-    num_required_args = length(arg_types)
     if length(arg_types) >= 1
         va = arg_types[end]
         if kind(va) == K"..."
             @chk numchildren(va) == 1
             # Ok: vararg function
-            vararg_type = va
-            if length(arg_types) <= 1
-                throw(LoweringError(vararg_type, "C ABI prohibits vararg without one required argument"))
-            else
-                num_required_args = length(arg_types) - 1
+            vararg_type = expand_ccall_argtype(ctx, va[1])
+            arg_types = arg_types[1:end-1]
+            if length(arg_types) === 0
+                throw(LoweringError(va, "C ABI prohibits vararg without one required argument"))
             end
         end
     end
     # todo: use multi-range errors here
-    if length(args) < num_required_args
+    if length(args) < length(arg_types)
         throw(LoweringError(ex, "Too few arguments in ccall compared to argument types"))
     elseif length(args) > length(arg_types) && isnothing(vararg_type)
         throw(LoweringError(ex, "More arguments than types in ccall"))
     end
     sctx = with_stmts(ctx)
     expanded_types = SyntaxList(ctx)
-    for (i, argt) in enumerate(arg_types)
+    for argt in arg_types
         if kind(argt) == K"..."
-            if i == length(arg_types)
-                argt = argt[1]
-            else
-                throw(LoweringError(argt, "only the trailing ccall argument type should have `...`"))
-            end
-        end
-        if is_same_identifier_like(argt, "Any")
-            # Special rule: Any becomes core.Any regardless of the module
-            # scope, and don't need GC roots.
-            argt = @ast ctx argt "Any"::K"core"
+            throw(LoweringError(argt, "only the trailing ccall argument type should have `...`"))
         end
-        push!(expanded_types, expand_forms_2(ctx, argt))
+        push!(expanded_types, expand_ccall_argtype(ctx, argt))
     end
-    #
+    for _ in length(arg_types)+1:length(args)
+        push!(expanded_types, vararg_type)
+    end
+
     # An improvement might be wrap the use of types in cconvert in a special
     # K"global_scope" expression which modifies the scope resolution. This
     # would at least make the rules self consistent if not pretty.
@@ -1843,7 +1845,7 @@ function expand_ccall(ctx, ex)
                     expanded_types...
                 ]
             ]
-            (isnothing(vararg_type) ? 0 : num_required_args)::K"Integer"
+            (isnothing(vararg_type) ? 0 : length(arg_types))::K"Integer"
             if isnothing(cconv)
                 "ccall"::K"Symbol"
             else

JuliaLowering/test/function_calls_ir.jl

@@ -406,14 +406,15 @@ ccall(:printf, Cint, (Cstring, Cstring...), "%s = %s\n", "2 + 2", "5")
 #---------------------
 1   TestMod.Cstring
 2   TestMod.Cstring
-3   (call top.cconvert %₁ "%s = %s\n")
-4   (call top.cconvert %₂ "2 + 2")
-5   (call top.cconvert %₂ "5")
-6   (call top.unsafe_convert %₁ %₃)
-7   (call top.unsafe_convert %₂ %₄)
+3   TestMod.Cstring
+4   (call top.cconvert %₁ "%s = %s\n")
+5   (call top.cconvert %₂ "2 + 2")
+6   (call top.cconvert %₃ "5")
+7   (call top.unsafe_convert %₁ %₄)
 8   (call top.unsafe_convert %₂ %₅)
-9   (foreigncall :printf (static_eval TestMod.Cint) (static_eval (call core.svec TestMod.Cstring TestMod.Cstring TestMod.Cstring)) 1 :ccall %₆ %₇ %₈ %₃ %₄ %₅)
-10  (return %₉)
+9   (call top.unsafe_convert %₃ %₆)
+10  (foreigncall :printf (static_eval TestMod.Cint) (static_eval (call core.svec TestMod.Cstring TestMod.Cstring TestMod.Cstring)) 1 :ccall %₇ %₈ %₉ %₄ %₅ %₆)
+11  (return %₁₀)
 
 ########################################
 # Error: ccall with too few arguments

JuliaLowering/test/misc.jl

@@ -47,6 +47,28 @@ end
 @test JuliaLowering.include_string(test_mod, """
 ccall(:strlen, Csize_t, (Cstring,), "asdfg")
 """) == 5
+@test JuliaLowering.include_string(test_mod, """
+function cvarargs_0()
+    strp = Ref{Ptr{Cchar}}(0)
+    fmt = "hi"
+    len = ccall(:asprintf, Cint, (Ptr{Ptr{Cchar}}, Cstring, Cfloat...), strp, fmt)
+    str = unsafe_string(strp[], len)
+    Libc.free(strp[])
+    return str
+end
+""") isa Function
+@test test_mod.cvarargs_0() == "hi"
+@test JuliaLowering.include_string(test_mod, """
+function cvarargs_2(arg1::Float64, arg2::Float64)
+    strp = Ref{Ptr{Cchar}}(0)
+    fmt = "%3.1f %3.1f"
+    len = ccall(:asprintf, Cint, (Ptr{Ptr{Cchar}}, Cstring, Cfloat...), strp, fmt, arg1, arg2)
+    str = unsafe_string(strp[], len)
+    Libc.free(strp[])
+    return str
+end
+""") isa Function
+@test test_mod.cvarargs_2(1.1, 2.2) == "1.1 2.2"
 
 # cfunction
 JuliaLowering.include_string(test_mod, """

JuliaLowering/test/misc_ir.jl

@@ -455,15 +455,14 @@ ccall(:fcntl, Cint, (RawFD, Cint, Cint...), s, F_GETFL)
 #---------------------
 1   TestMod.RawFD
 2   TestMod.Cint
-3   TestMod.Cint
-4   TestMod.s
-5   (call top.cconvert %₁ %₄)
-6   TestMod.F_GETFL
-7   (call top.cconvert %₂ %₆)
-8   (call top.unsafe_convert %₁ %₅)
-9   (call top.unsafe_convert %₂ %₇)
-10  (foreigncall :fcntl (static_eval TestMod.Cint) (static_eval (call core.svec TestMod.RawFD TestMod.Cint TestMod.Cint)) 2 :ccall %₈ %₉ %₅ %₇)
-11  (return %₁₀)
+3   TestMod.s
+4   (call top.cconvert %₁ %₃)
+5   TestMod.F_GETFL
+6   (call top.cconvert %₂ %₅)
+7   (call top.unsafe_convert %₁ %₄)
+8   (call top.unsafe_convert %₂ %₆)
+9   (foreigncall :fcntl (static_eval TestMod.Cint) (static_eval (call core.svec TestMod.RawFD TestMod.Cint)) 2 :ccall %₇ %₈ %₄ %₆)
+10  (return %₉)
 
 ########################################
 # Error: No return annotation on @ccall