Add AmbiguousError and use it in codegen

Author: timholy

base/base.jl

@@ -34,6 +34,11 @@ type MethodError <: Exception
     args
 end
 
+type AmbiguousError <: Exception
+    args
+    srcinfo
+end
+
 type EOFError <: Exception end
 
 type DimensionMismatch <: Exception

base/exports.jl

@@ -152,6 +152,7 @@ export
     Cwstring,
 
 # Exceptions
+    AmbiguousError,
     ArgumentError,
     DimensionMismatch,
     CapturedException,

base/reflection.jl

@@ -170,10 +170,11 @@ end
 
 tt_cons(t::ANY, tup::ANY) = (@_pure_meta; Tuple{t, (isa(tup, Type) ? tup.parameters : tup)...})
 
-code_lowered(f, t::ANY=Tuple) = map(m -> (m::Method).lambda_template, methods(f, t))
+code_lowered(f, t::ANY=Tuple) = map(m -> (m::Method).lambda_template, checked_methods(f, t))
 
 # low-level method lookup functions used by the compiler
 
+checkambiguity(tt::Type, m::Method) = ccall(:jl_list_call_ambiguities, Any, (Any, Any), tt, m)
 function _methods(f::ANY,t::ANY,lim)
     ft = isa(f,Type) ? Type{f} : typeof(f)
     if isa(t,Type)
@@ -249,6 +250,18 @@ function methods(f::ANY, t::ANY)
     return MethodList(Method[m[3] for m in _methods(f,t,-1)], typeof(f).name.mt)
 end
 
+function checked_methods(f::ANY, t::ANY)
+    ms = methods(f, t)
+    tt = isa(t, DataType) ? Tuple{typeof(f), t.parameters...} : Tuple{typeof(f), t...}
+    for m in ms
+        srcinfo = checkambiguity(tt, m)
+        if srcinfo != nothing
+            throw(AmbiguousError(tt, srcinfo))
+        end
+    end
+    ms
+end
+
 methods(f::Builtin) = MethodList(Method[], typeof(f).name.mt)
 
 function methods(f::ANY)
@@ -339,8 +352,14 @@ end
 function code_typed(f::ANY, types::ANY=Tuple; optimize=true)
     ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
     types = to_tuple_type(types)
+    typesf = Tuple{typeof(f), types.parameters...}
     asts = []
     for x in _methods(f,types,-1)
+        linfo = func_for_method_checked(x[3], types)
+        srcinfo = checkambiguity(typesf, x[3])
+        if srcinfo != nothing
+            throw(AmbiguousError(typesf, srcinfo))
+        end
         linfo = func_for_method_checked(x[3], types)
         if optimize
             (li, ty, inf) = Core.Inference.typeinf(linfo, x[1], x[2], true)

base/replutil.jl

@@ -247,6 +247,26 @@ end
 striptype{T}(::Type{T}) = T
 striptype(::Any) = nothing
 
+function showerror(io::IO, ex::AmbiguousError)
+    f = ex.args.parameters[1]
+    args = ex.args.parameters[2:end]
+    fname = string(f.name.name)[2:end]
+    print(io, "AmbiguousError: ", fname, "(")
+    for (i,a) in enumerate(args)
+        print(io, "::", a)
+        i == length(args) ? print(io, ")") : print(io, ", ")
+    end
+    print(io, " is ambiguous.")
+    candidates = ex.srcinfo
+    if candidates != true
+        print(io, " Candidates:")
+        for i = 1:2:length(candidates)
+            print(io, "\n  ", candidates[i], ":", candidates[i+1])
+        end
+    end
+    nothing
+end
+
 #Show an error by directly calling jl_printf.
 #Useful in Base submodule __init__ functions where STDERR isn't defined yet.
 function showerror_nostdio(err, msg::AbstractString)

src/alloc.c

@@ -50,6 +50,7 @@ jl_datatype_t *jl_errorexception_type=NULL;
 jl_datatype_t *jl_argumenterror_type;
 jl_datatype_t *jl_typeerror_type;
 jl_datatype_t *jl_methoderror_type;
+jl_datatype_t *jl_ambiguouserror_type;
 jl_datatype_t *jl_loaderror_type;
 jl_datatype_t *jl_initerror_type;
 jl_datatype_t *jl_undefvarerror_type;
@@ -476,6 +477,7 @@ static jl_lambda_info_t *jl_copy_lambda(jl_lambda_info_t *linfo)
     new_linfo->nargs = linfo->nargs;
     new_linfo->isva = linfo->isva;
     new_linfo->rettype = linfo->rettype;
+    new_linfo->def = linfo->def;
     return new_linfo;
 }
 

src/codegen.cpp

@@ -352,6 +352,7 @@ static Function *jlthrow_func;
 static Function *jlerror_func;
 static Function *jltypeerror_func;
 static Function *jlundefvarerror_func;
+static Function *jlambiguouserror_func;
 static Function *jlboundserror_func;
 static Function *jluboundserror_func;
 static Function *jlvboundserror_func;
@@ -1094,7 +1095,7 @@ void *jl_get_llvmf(jl_tupletype_t *tt, bool getwrapper, bool getdeclarations)
     jl_lambda_info_t *linfo = NULL;
     JL_GC_PUSH2(&linfo, &tt);
     if (tt != NULL) {
-        linfo = jl_get_specialization1(tt);
+        linfo = jl_checked_specialization1(tt);
         if (linfo == NULL) {
             jl_typemap_entry_t *entry;
             linfo = jl_method_lookup_by_type(
@@ -1103,7 +1104,6 @@ void *jl_get_llvmf(jl_tupletype_t *tt, bool getwrapper, bool getdeclarations)
                 JL_GC_POP();
                 return NULL;
             }
-            check_ambig_call(linfo->def, tt);
         }
     }
     if (linfo == NULL) {
@@ -2687,6 +2687,19 @@ static jl_cgval_t emit_call_function_object(jl_lambda_info_t *li, const jl_cgval
                            expr_type(callexpr, ctx), ctx);
 }
 
+static void emit_ambiguous_call_error(jl_tupletype_t *tt, jl_array_t *ambiguities, jl_codectx_t *ctx)
+{
+    //builder.SetInsertPoint(err);
+#ifdef LLVM37
+    builder.CreateCall(prepare_call(jlambiguouserror_func), { literal_pointer_val((jl_value_t*)tt), literal_pointer_val((jl_value_t*)ambiguities) });
+#else
+    builder.CreateCall2(prepare_call(jlambiguouserror_func), literal_pointer_val((jl_value_t*)tt), literal_pointer_val((jl_value_t*)ambiguities));
+#endif
+    builder.CreateUnreachable();
+    BasicBlock *cont = BasicBlock::Create(jl_LLVMContext,"after_error",ctx->f);
+    builder.SetInsertPoint(cont);
+}
+
 static jl_cgval_t emit_call(jl_expr_t *ex, jl_codectx_t *ctx)
 {
     jl_value_t *expr = (jl_value_t*)ex;
@@ -2696,9 +2709,10 @@ static jl_cgval_t emit_call(jl_expr_t *ex, jl_codectx_t *ctx)
     Value *theFptr = NULL;
     jl_cgval_t result;
     jl_value_t *aty = NULL;
+    jl_value_t *ambiguities = NULL;
 
     jl_function_t *f = (jl_function_t*)static_eval(args[0], ctx, true);
-    JL_GC_PUSH2(&f, &aty);
+    JL_GC_PUSH3(&f, &aty, &ambiguities);
     if (f != NULL) {
         // function is a compile-time constant
         if (jl_typeis(f, jl_intrinsic_type)) {
@@ -2738,30 +2752,39 @@ static jl_cgval_t emit_call(jl_expr_t *ex, jl_codectx_t *ctx)
                   jl_sprint(args[0]),
                   jl_sprint((jl_value_t*)aty));
               }*/
-            jl_lambda_info_t *li = jl_get_specialization1((jl_tupletype_t*)aty);
+            jl_typemap_entry_t *entry;
+            jl_lambda_info_t *li = jl_get_specialization1((jl_tupletype_t*)aty, &entry);
             if (li != NULL) {
-                assert(li->functionObjectsDecls.functionObject != NULL);
-                theFptr = (Value*)li->functionObjectsDecls.functionObject;
-                jl_cgval_t fval;
-                if (f != NULL) {
-                    // TODO jb/functions: avoid making too many roots here
-                    if (!jl_is_globalref(args[0]) && !jl_is_symbol(args[0]) &&
-                        !jl_is_leaf_type(f)) {
-                        if (ctx->linfo->def)
-                            jl_add_linfo_root(ctx->linfo, f);
-                        else // for toplevel thunks, just write the value back to the AST to root it
-                            jl_cellset(ex->args, 0, f);
-                    }
-                    fval = mark_julia_const((jl_value_t*)f);
+                jl_method_t *m = li->def;
+                ambiguities = jl_list_call_ambiguities_((jl_tupletype_t*)aty, m);
+                if (ambiguities != jl_nothing) {
+                    emit_ambiguous_call_error((jl_tupletype_t*)aty,
+                                          (jl_array_t*)ambiguities, ctx);
                 }
                 else {
-                    fval = emit_expr(args[0], ctx);
+                    assert(li->functionObjectsDecls.functionObject != NULL);
+                    theFptr = (Value*)li->functionObjectsDecls.functionObject;
+                    jl_cgval_t fval;
+                    if (f != NULL) {
+                        // TODO jb/functions: avoid making too many roots here
+                        if (!jl_is_globalref(args[0]) && !jl_is_symbol(args[0]) &&
+                            !jl_is_leaf_type(f)) {
+                            if (ctx->linfo->def)
+                                jl_add_linfo_root(ctx->linfo, f);
+                            else // for toplevel thunks, just write the value back to the AST to root it
+                                jl_cellset(ex->args, 0, f);
+                        }
+                        fval = mark_julia_const((jl_value_t*)f);
+                    }
+                    else {
+                        fval = emit_expr(args[0], ctx);
+                    }
+                    if (ctx->linfo->def) // root this li in case it gets deleted from the cache in `f`
+                        jl_add_linfo_root(ctx->linfo, (jl_value_t*)li);
+                    result = emit_call_function_object(li, fval, theFptr, args, nargs, expr, ctx);
+                    JL_GC_POP();
+                    return result;
                 }
-                if (ctx->linfo->def) // root this li in case it gets deleted from the cache in `f`
-                    jl_add_linfo_root(ctx->linfo, (jl_value_t*)li);
-                result = emit_call_function_object(li, fval, theFptr, args, nargs, expr, ctx);
-                JL_GC_POP();
-                return result;
             }
         }
     }
@@ -3520,7 +3543,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
         jl_error("va_arg syntax not allowed for cfunction argument list");
 
     const char *name = "cfunction";
-    jl_lambda_info_t *lam = jl_get_specialization1((jl_tupletype_t*)sigt);
+    jl_lambda_info_t *lam = jl_checked_specialization1((jl_tupletype_t*)sigt);
     jl_value_t *astrt = (jl_value_t*)jl_any_type;
     if (lam != NULL) {
         name = jl_symbol_name(lam->def->name);
@@ -5198,6 +5221,16 @@ static void init_julia_llvm_env(Module *m)
     jlundefvarerror_func->setDoesNotReturn();
     add_named_global(jlundefvarerror_func, &jl_undefined_var_error);
 
+    std::vector<Type*> args2_ambiguouserror(0);
+    args2_ambiguouserror.push_back(T_pjlvalue);
+    args2_ambiguouserror.push_back(T_pjlvalue);
+    jlambiguouserror_func =
+        Function::Create(FunctionType::get(T_void, args2_ambiguouserror, false),
+                         Function::ExternalLinkage,
+                         "jl_ambiguous_call_error", m);
+    jlambiguouserror_func->setDoesNotReturn();
+    add_named_global(jlambiguouserror_func, &jl_ambiguous_call_error);
+
     std::vector<Type*> args2_boundserrorv(0);
     args2_boundserrorv.push_back(T_pjlvalue);
     args2_boundserrorv.push_back(T_psize);