make eval and method_exists no longer builtins

switch `arraylen` from builtin to intrinsic

base/boot.jl

@@ -147,15 +147,15 @@ export
     Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode, SymbolNode, TopNode,
     GlobalRef, NewvarNode, GenSym,
     # object model functions
-    fieldtype, getfield, setfield!, nfields, throw, tuple, is, ===, isdefined,
-    # arraylen, arrayref, arrayset, arraysize,
+    fieldtype, getfield, setfield!, nfields, throw, tuple, is, ===, isdefined, eval,
+    # arrayref, arrayset, arraysize,
     # _apply, kwcall,
     # sizeof    # not exported, to avoid conflicting with Base.sizeof
     # type reflection
     issubtype, typeof, isa,
     # typeassert, apply_type,
     # method reflection
-    applicable, invoke, method_exists,
+    applicable, invoke,
     # constants
     nothing, Main,
     # intrinsics module
@@ -174,7 +174,7 @@ export
     #mul_int, ne_float, ne_int, neg_float, neg_int, not_int, or_int, rem_float,
     #sdiv_int, shl_int, sitofp, sle_int, slt_int, smod_int,
     #srem_int, sub_float, sub_int, trunc_int, udiv_int, uitofp,
-    #ule_int, ult_int, unbox, urem_int, xor_int, sext_int, zext_int
+    #ule_int, ult_int, unbox, urem_int, xor_int, sext_int, zext_int, arraylen
 
 
 const (===) = is
@@ -260,6 +260,9 @@ typealias ByteString Union{ASCIIString,UTF8String}
 
 include(fname::ByteString) = ccall(:jl_load_, Any, (Any,), fname)
 
+eval(e::ANY) = eval(Main, e)
+eval(m::Module, e::ANY) = ccall(:jl_toplevel_eval_in, Any, (Any, Any), m, e)
+
 # constructors for built-in types
 
 type WeakRef

base/coreimg.jl

@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 Main.Core.eval(Main.Core, :(baremodule Inference
-using Core: Intrinsics, arraylen, arrayref, arrayset, arraysize, _expr,
+using Core: Intrinsics, arrayref, arrayset, arraysize, _expr,
             kwcall, _apply, typeassert, apply_type, svec
 ccall(:jl_set_istopmod, Void, (Bool,), false)
 

base/exports.jl

@@ -1084,6 +1084,7 @@ export
     isgeneric,
     isinteractive,
     less,
+    method_exists,
     methods,
     methodswith,
     module_name,

base/inference.jl

@@ -113,7 +113,7 @@ cmp_tfunc = (x,y)->Bool
 isType(t::ANY) = isa(t,DataType) && is((t::DataType).name,Type.name)
 
 const IInf = typemax(Int) # integer infinity
-const n_ifunc = reinterpret(Int32,llvmcall)+1
+const n_ifunc = reinterpret(Int32,arraylen)+1
 const t_ifunc = Array{Tuple{Int,Int,Function},1}(n_ifunc)
 const t_ffunc_key = Array{Function,1}(0)
 const t_ffunc_val = Array{Tuple{Int,Int,Function},1}(0)
@@ -162,16 +162,15 @@ add_tfunc(eval(Core.Intrinsics,:cglobal), 1, 2,
 add_tfunc(eval(Core.Intrinsics,:select_value), 3, 3,
     # TODO: return Bottom if cnd is definitely not a Bool
     (cnd, x, y)->Union{x,y})
+add_tfunc(eval(Core.Intrinsics,:arraylen), 1, 1, x->Int)
 add_tfunc(is, 2, 2, cmp_tfunc)
 add_tfunc(issubtype, 2, 2, cmp_tfunc)
 add_tfunc(isa, 2, 2, cmp_tfunc)
 add_tfunc(isdefined, 1, IInf, (args...)->Bool)
 add_tfunc(Core.sizeof, 1, 1, x->Int)
 add_tfunc(nfields, 1, 1, x->Int)
 add_tfunc(_expr, 1, IInf, (args...)->Expr)
-add_tfunc(method_exists, 2, 2, cmp_tfunc)
 add_tfunc(applicable, 1, IInf, (f, args...)->Bool)
-add_tfunc(arraylen, 1, 1, x->Int)
 #add_tfunc(arrayref, 2,IInf,(a,i...)->(isa(a,DataType) && a<:Array ?
 #                                     a.parameters[1] : Any))
 #add_tfunc(arrayset, 3, IInf, (a,v,i...)->a)

base/reflection.jl

@@ -345,3 +345,14 @@ function function_module(f, types::ANY)
     end
     m[1].func.code.module
 end
+
+function method_exists(f::ANY, t::ANY)
+    t = to_tuple_type(t)
+    if !isa(f,Function)
+        t = Tuple{isa(f,Type) ? Type{f} : typeof(f), t.parameters...}
+        f = call
+    elseif !isgeneric(f)
+        throw(ArgumentError("argument is not a generic function"))
+    end
+    return ccall(:jl_method_exists, Cint, (Any, Any), f.env, t) != 0
+end

base/sysimg.jl

@@ -4,7 +4,7 @@ import Core.Intrinsics.ccall
 
 baremodule Base
 
-using Core: Intrinsics, arraylen, arrayref, arrayset, arraysize, _expr,
+using Core: Intrinsics, arrayref, arrayset, arraysize, _expr,
             kwcall, _apply, typeassert, apply_type, svec
 ccall(:jl_set_istopmod, Void, (Bool,), true)
 

src/array.c

@@ -404,13 +404,6 @@ DLLEXPORT size_t jl_array_len_(jl_array_t *a)
 }
 #endif
 
-JL_CALLABLE(jl_f_arraylen)
-{
-    JL_NARGS(arraylen, 1, 1);
-    JL_TYPECHK(arraylen, array, args[0]);
-    return jl_box_long(jl_array_len((jl_array_t*)args[0]));
-}
-
 JL_CALLABLE(jl_f_arraysize)
 {
     JL_NARGS(arraysize, 2, 2);

src/builtin_proto.h

@@ -18,20 +18,17 @@ JL_CALLABLE(jl_f_isa);
 JL_CALLABLE(jl_f_typeassert);
 JL_CALLABLE(jl_f_apply);
 JL_CALLABLE(jl_f_kwcall);
-JL_CALLABLE(jl_f_top_eval);
 JL_CALLABLE(jl_f_isdefined);
 JL_CALLABLE(jl_f_tuple);
 JL_CALLABLE(jl_f_svec);
 JL_CALLABLE(jl_f_get_field);
 JL_CALLABLE(jl_f_set_field);
 JL_CALLABLE(jl_f_field_type);
-JL_CALLABLE(jl_f_arraylen);
 JL_CALLABLE(jl_f_arrayref);
 JL_CALLABLE(jl_f_arrayset);
 JL_CALLABLE(jl_f_arraysize);
 JL_CALLABLE(jl_f_instantiate_type);
 JL_CALLABLE(jl_f_typevar);
-JL_CALLABLE(jl_f_methodexists);
 JL_CALLABLE(jl_f_applicable);
 JL_CALLABLE(jl_f_invoke);
 JL_CALLABLE(jl_f_new_expr);

src/builtins.c

@@ -543,7 +543,12 @@ JL_CALLABLE(jl_f_kwcall)
 
 extern int jl_lineno;
 
-DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex, int delay_warn)
+DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex)
+{
+    return jl_toplevel_eval_in_warn(m, ex, 0);
+}
+
+DLLEXPORT jl_value_t *jl_toplevel_eval_in_warn(jl_module_t *m, jl_value_t *ex, int delay_warn)
 {
     static int jl_warn_on_eval = 0;
     int last_delay_warn = jl_warn_on_eval;
@@ -587,23 +592,6 @@ DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex, int de
     return v;
 }
 
-JL_CALLABLE(jl_f_top_eval)
-{
-    jl_module_t *m;
-    jl_value_t *ex;
-    if (nargs == 1) {
-        m = jl_main_module;
-        ex = args[0];
-    }
-    else {
-        JL_NARGS(eval, 2, 2);
-        JL_TYPECHK(eval, module, args[0]);
-        m = (jl_module_t*)args[0];
-        ex = args[1];
-    }
-    return jl_toplevel_eval_in(m, ex, 0);
-}
-
 JL_CALLABLE(jl_f_isdefined)
 {
     jl_module_t *m = jl_current_module;
@@ -1057,29 +1045,6 @@ static void jl_check_type_tuple(jl_value_t *t, jl_sym_t *name, const char *ctx)
         jl_type_error_rt(name->name, ctx, (jl_value_t*)jl_type_type, t);
 }
 
-JL_CALLABLE(jl_f_methodexists)
-{
-    JL_NARGS(method_exists, 2, 2);
-    JL_TYPECHK(method_exists, function, args[0]);
-    if (!jl_is_gf(args[0]))
-        jl_error("method_exists: not a generic function");
-    jl_value_t *argtypes = args[1];
-    JL_GC_PUSH1(&argtypes);
-    if (jl_is_tuple(args[1])) {
-        // TODO: maybe deprecation warning, better checking
-        argtypes = (jl_value_t*)jl_apply_tuple_type_v((jl_value_t**)jl_data_ptr(argtypes),
-                                                      jl_nfields(argtypes));
-    }
-    else {
-        jl_check_type_tuple(args[1], jl_gf_name(args[0]), "method_exists");
-    }
-    jl_value_t *res = jl_method_lookup_by_type(jl_gf_mtable(args[0]),
-                                               (jl_tupletype_t*)argtypes,0,0)!=jl_bottom_func ?
-        jl_true : jl_false;
-    JL_GC_POP();
-    return res;
-}
-
 JL_CALLABLE(jl_f_applicable)
 {
     JL_NARGSV(applicable, 1);
@@ -1228,30 +1193,31 @@ void jl_init_primitives(void)
     add_builtin_func("issubtype", jl_f_subtype);
     add_builtin_func("isa", jl_f_isa);
     add_builtin_func("typeassert", jl_f_typeassert);
-    add_builtin_func("_apply", jl_f_apply);
-    add_builtin_func("kwcall", jl_f_kwcall);
     add_builtin_func("throw", jl_f_throw);
     add_builtin_func("tuple", jl_f_tuple);
-    add_builtin_func("svec", jl_f_svec);
-    add_builtin_func("method_exists", jl_f_methodexists);
-    add_builtin_func("applicable", jl_f_applicable);
-    add_builtin_func("invoke", jl_f_invoke);
-    add_builtin_func("eval", jl_f_top_eval);
-    add_builtin_func("isdefined", jl_f_isdefined);
 
-    // functions for internal use
+    // field access
     add_builtin_func("getfield",  jl_f_get_field);
     add_builtin_func("setfield!",  jl_f_set_field);
     add_builtin_func("fieldtype", jl_f_field_type);
     add_builtin_func("nfields", jl_f_nfields);
-    add_builtin_func("_expr", jl_f_new_expr);
+    add_builtin_func("isdefined", jl_f_isdefined);
 
-    add_builtin_func("arraylen", jl_f_arraylen);
+    // array primitives
     add_builtin_func("arrayref", jl_f_arrayref);
     add_builtin_func("arrayset", jl_f_arrayset);
     add_builtin_func("arraysize", jl_f_arraysize);
 
+    // method table utils
+    add_builtin_func("applicable", jl_f_applicable);
+    add_builtin_func("invoke", jl_f_invoke);
+
+    // internal functions
     add_builtin_func("apply_type", jl_f_instantiate_type);
+    add_builtin_func("_apply", jl_f_apply);
+    add_builtin_func("kwcall", jl_f_kwcall);
+    add_builtin_func("_expr", jl_f_new_expr);
+    add_builtin_func("svec", jl_f_svec);
 
     // builtin types
     add_builtin("Any", (jl_value_t*)jl_any_type);

src/codegen.cpp

@@ -2374,17 +2374,6 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         return true;
     }
 
-    else if (f->fptr == &jl_f_arraylen && nargs==1) {
-        jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
-        if (jl_is_array_type(aty)) {
-            // todo: also allow e.g. Union of several array types
-            jl_cgval_t arg1 = emit_expr(args[1], ctx);
-            *ret = mark_julia_type(emit_arraylen(arg1, args[1], ctx), false, jl_long_type);
-            JL_GC_POP();
-            return true;
-        }
-    }
-
     else if (f->fptr == &jl_f_arraysize && nargs==2) {
         jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
         jl_value_t *ity = expr_type(args[2], ctx); rt2 = ity;
@@ -5535,17 +5524,14 @@ static void init_julia_llvm_env(Module *m)
     builtin_func_map[jl_f_throw] = jlcall_func_to_llvm("jl_f_throw", (void*)&jl_f_throw, m);
     builtin_func_map[jl_f_tuple] = jlcall_func_to_llvm("jl_f_tuple", (void*)&jl_f_tuple, m);
     builtin_func_map[jl_f_svec] = jlcall_func_to_llvm("jl_f_svec", (void*)&jl_f_svec, m);
-    builtin_func_map[jl_f_methodexists] = jlcall_func_to_llvm("jl_f_methodexists", (void*)&jl_f_methodexists, m);
     builtin_func_map[jl_f_applicable] = jlcall_func_to_llvm("jl_f_applicable", (void*)&jl_f_applicable, m);
     builtin_func_map[jl_f_invoke] = jlcall_func_to_llvm("jl_f_invoke", (void*)&jl_f_invoke, m);
-    builtin_func_map[jl_f_top_eval] = jlcall_func_to_llvm("jl_f_top_eval", (void*)&jl_f_top_eval, m);
     builtin_func_map[jl_f_isdefined] = jlcall_func_to_llvm("jl_f_isdefined", (void*)&jl_f_isdefined, m);
     builtin_func_map[jl_f_get_field] = jlcall_func_to_llvm("jl_f_get_field", (void*)&jl_f_get_field, m);
     builtin_func_map[jl_f_set_field] = jlcall_func_to_llvm("jl_f_set_field", (void*)&jl_f_set_field, m);
     builtin_func_map[jl_f_field_type] = jlcall_func_to_llvm("jl_f_field_type", (void*)&jl_f_field_type, m);
     builtin_func_map[jl_f_nfields] = jlcall_func_to_llvm("jl_f_nfields", (void*)&jl_f_nfields, m);
     builtin_func_map[jl_f_new_expr] = jlcall_func_to_llvm("jl_f_new_expr", (void*)&jl_f_new_expr, m);
-    builtin_func_map[jl_f_arraylen] = jlcall_func_to_llvm("jl_f_arraylen", (void*)&jl_f_arraylen, m);
     builtin_func_map[jl_f_arrayref] = jlcall_func_to_llvm("jl_f_arrayref", (void*)&jl_f_arrayref, m);
     builtin_func_map[jl_f_arrayset] = jlcall_func_to_llvm("jl_f_arrayset", (void*)&jl_f_arrayset, m);
     builtin_func_map[jl_f_arraysize] = jlcall_func_to_llvm("jl_f_arraysize", (void*)&jl_f_arraysize, m);

src/dump.c

@@ -70,13 +70,11 @@ static htable_t fptr_to_id;
 // (reverse of fptr_to_id)
 static jl_fptr_t id_to_fptrs[] = {
   NULL, NULL,
-  jl_f_throw, jl_f_is, jl_f_no_function, jl_f_typeof,
-  jl_f_subtype, jl_f_isa, jl_f_typeassert, jl_f_apply,
-  jl_f_top_eval, jl_f_isdefined, jl_f_tuple, jl_f_svec,
+  jl_f_throw, jl_f_is, jl_f_no_function, jl_f_typeof, jl_f_subtype, jl_f_isa,
+  jl_f_typeassert, jl_f_apply, jl_f_isdefined, jl_f_tuple, jl_f_svec,
   jl_f_get_field, jl_f_set_field, jl_f_field_type, jl_f_nfields,
-  jl_f_arraylen, jl_f_arrayref, jl_f_arrayset, jl_f_arraysize,
-  jl_f_instantiate_type, jl_f_kwcall, jl_trampoline,
-  jl_f_methodexists, jl_f_applicable, jl_f_invoke,
+  jl_f_arrayref, jl_f_arrayset, jl_f_arraysize, jl_f_instantiate_type,
+  jl_f_kwcall, jl_trampoline, jl_f_applicable, jl_f_invoke,
   jl_apply_generic, jl_unprotect_stack, jl_f_sizeof, jl_f_new_expr,
   jl_f_intrinsic_call,
   NULL };

src/gf.c

@@ -966,7 +966,7 @@ DLLEXPORT jl_function_t *jl_instantiate_staged(jl_methlist_t *m, jl_tupletype_t
         }
         ex = oldast;
     }
-    func = (jl_function_t*)jl_toplevel_eval_in(m->func->linfo->module, (jl_value_t*)ex, 1); // need to eval macros in the right module, but not give a warning for the `eval` call unless that results in a call to `eval`
+    func = (jl_function_t*)jl_toplevel_eval_in_warn(m->func->linfo->module, (jl_value_t*)ex, 1); // need to eval macros in the right module, but not give a warning for the `eval` call unless that results in a call to `eval`
     func->linfo->name = m->func->linfo->name;
     JL_GC_POP();
     return func;
@@ -1416,6 +1416,11 @@ jl_function_t *jl_method_lookup_by_type(jl_methtable_t *mt, jl_tupletype_t *type
     return sf;
 }
 
+DLLEXPORT int jl_method_exists(jl_methtable_t *mt, jl_tupletype_t *types)
+{
+    return jl_method_lookup_by_type(mt, types, 0, 0) != jl_bottom_func;
+}
+
 jl_function_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, size_t nargs, int cache)
 {
     jl_function_t *sf = jl_method_table_assoc_exact(mt, args, nargs);

src/init.c

@@ -594,8 +594,6 @@ void _julia_init(JL_IMAGE_SEARCH rel)
     if (jl_base_module != NULL) {
         jl_add_standard_imports(jl_main_module);
     }
-    // eval() uses Main by default, so Main.eval === Core.eval
-    jl_module_import(jl_main_module, jl_core_module, jl_symbol("eval"));
     jl_current_module = jl_main_module;
     jl_root_task->current_module = jl_current_module;
 

src/intrinsics.cpp

@@ -920,6 +920,9 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
     case ccall: return emit_ccall(args, nargs, ctx);
     case cglobal: return emit_cglobal(args, nargs, ctx);
     case llvmcall: return emit_llvmcall(args, nargs, ctx);
+    case arraylen:
+        return mark_julia_type(emit_arraylen(emit_expr(args[1], ctx), args[1], ctx), false,
+                               jl_long_type);
 #if 0 // this section enables runtime-intrinsics (e.g. for testing), and disables their llvm counterparts
     default:
         int ldepth = ctx->gc.argDepth;

src/intrinsics.h

@@ -101,6 +101,8 @@
     ALIAS(ccall, ccall) \
     ALIAS(cglobal, cglobal) \
     ALIAS(llvmcall, llvmcall) \
+    /* object access */ \
+    ADD_I(arraylen, 1) \
     /*  hidden intrinsics */ \
     ADD_HIDDEN(fptoui_auto, 1) \
     ADD_HIDDEN(fptosi_auto, 1)

src/julia.h

@@ -1249,7 +1249,8 @@ DLLEXPORT const char *jl_lookup_soname(const char *pfx, size_t n);
 // compiler
 void jl_compile(jl_function_t *f);
 DLLEXPORT jl_value_t *jl_toplevel_eval(jl_value_t *v);
-DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex, int delay_warn);
+DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex);
+DLLEXPORT jl_value_t *jl_toplevel_eval_in_warn(jl_module_t *m, jl_value_t *ex, int delay_warn);
 jl_value_t *jl_eval_global_var(jl_module_t *m, jl_sym_t *e);
 DLLEXPORT jl_value_t *jl_load(const char *fname, size_t len);
 jl_value_t *jl_parse_eval_all(const char *fname, size_t len);

src/julia_internal.h

@@ -317,8 +317,7 @@ DLLEXPORT jl_value_t *jl_copysign_float(jl_value_t *a, jl_value_t *b);
 DLLEXPORT jl_value_t *jl_flipsign_int(jl_value_t *a, jl_value_t *b);
 
 DLLEXPORT jl_value_t *jl_select_value(jl_value_t *isfalse, jl_value_t *a, jl_value_t *b);
-
-
+DLLEXPORT jl_value_t *jl_arraylen(jl_value_t *a);
 
 #ifdef __cplusplus
 }

src/runtime_intrinsics.c

@@ -931,3 +931,8 @@ DLLEXPORT jl_value_t *jl_select_value(jl_value_t *isfalse, jl_value_t *a, jl_val
     JL_TYPECHK(isfalse, bool, isfalse);
     return (isfalse == jl_false ? b : a);
 }
+
+DLLEXPORT jl_value_t *jl_arraylen(jl_value_t *a)
+{
+    return jl_box_long(jl_array_len((jl_array_t*)a));
+}

src/toplevel.c

@@ -69,8 +69,6 @@ jl_module_t *jl_new_main_module(void)
                   (jl_value_t*)jl_main_module);
     jl_current_task->current_module = jl_main_module;
 
-    jl_module_import(jl_main_module, jl_core_module, jl_symbol("eval"));
-
     return old_main;
 }