diff --git a/bootstrap_ambig.txt b/bootstrap_ambig.txt new file mode 100644 index 00000000000000..e71f0691eb67db --- /dev/null +++ b/bootstrap_ambig.txt @@ -0,0 +1,417 @@ +~/julia$ make -j4 + PERL base/version_git.jl.phony + JULIA usr/lib/julia/sys.o +exports.jl +essentials.jl +base.jl +generator.jl +reflection.jl +options.jl +promotion.jl +tuple.jl +range.jl +expr.jl +error.jl +bool.jl +WARNING: New definition + promote_op(Base.#^, Type{Bool}, Type{#T<:Integer}) at bool.jl:64 +is ambiguous with: + promote_op(Any, Type{Bool}, Type{Bool}) at bool.jl:63. +To fix, define + promote_op(Base.#^, Type{Bool}, Type{Bool}) +before the new definition. +number.jl +int.jl +operators.jl +pointer.jl +refpointer.jl +WARNING: Method definition (::Type{#T<:Any})(Any) in module Inference at coreimg.jl:44 overwritten in module Base at sysimg.jl:50. +checked.jl +abstractarray.jl +subarray.jl +WARNING: New definition + similar(Base.SubArray, Any, Tuple{Vararg{Int64, N<:Any}}) at subarray.jl:70 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Int64, N<:Any}}) at abstractarray.jl:159. +To fix, define + similar(Base.SubArray, Type, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Base.SubArray, Any, Tuple{Vararg{Int64, N<:Any}}) at subarray.jl:70 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Integer, N<:Any}}) at abstractarray.jl:158. +To fix, define + similar(Base.SubArray, Type, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +array.jl +WARNING: New definition + similar(Array, Any, Tuple{Vararg{Int64, N<:Any}}) at array.jl:120 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Int64, N<:Any}}) at abstractarray.jl:159. +To fix, define + similar(Array, Type, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Array, Any, Tuple{Vararg{Int64, N<:Any}}) at array.jl:120 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Integer, N<:Any}}) at abstractarray.jl:158. +To fix, define + similar(Array, Type, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 1}, Any) at array.jl:125 +is ambiguous with: + similar(AbstractArray, Type) at abstractarray.jl:153. +To fix, define + similar(Array{T<:Any, 1}, Type) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 1}, Any) at array.jl:125 +is ambiguous with: + similar(AbstractArray{#T<:Any, N<:Any}, Tuple{Vararg{Integer, N<:Any}}) at abstractarray.jl:154. +To fix, define + similar(Array{#T<:Any, 1}, Tuple{Vararg{Integer, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 1}, Any) at array.jl:125 +is ambiguous with: + similar(AbstractArray{#T<:Any, N<:Any}, Integer...) at abstractarray.jl:155. +To fix, define + similar(Array{#T<:Any, 1}, Integer) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 1}, Any) at array.jl:125 +is ambiguous with: + similar(AbstractArray, Type, Integer...) at abstractarray.jl:156. +To fix, define + similar(Array{T<:Any, 1}, Type) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 2}, Any) at array.jl:128 +is ambiguous with: + similar(AbstractArray, Type) at abstractarray.jl:153. +To fix, define + similar(Array{T<:Any, 2}, Type) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 2}, Any) at array.jl:128 +is ambiguous with: + similar(AbstractArray{#T<:Any, N<:Any}, Tuple{Vararg{Integer, N<:Any}}) at abstractarray.jl:154. +To fix, define + similar(Array{#T<:Any, 2}, Tuple{Vararg{Integer, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 2}, Any) at array.jl:128 +is ambiguous with: + similar(AbstractArray{#T<:Any, N<:Any}, Integer...) at abstractarray.jl:155. +To fix, define + similar(Array{#T<:Any, 2}, Integer) +before the new definition. +WARNING: New definition + similar(Array{#T<:Any, 2}, Any) at array.jl:128 +is ambiguous with: + similar(AbstractArray, Type, Integer...) at abstractarray.jl:156. +To fix, define + similar(Array{T<:Any, 2}, Type) +before the new definition. +hashing.jl +rounding.jl +float.jl +complex.jl +rational.jl +WARNING: New definition + round(Type{#T<:Any}, Base.Rational{Bool}, Base.Rounding.RoundingMode) at rational.jl:343 +is ambiguous with: + round(Type{#T<:Any}, Base.Rational{#Tr<:Any}, Base.Rounding.RoundingMode{:Nearest}) at rational.jl:293. +To fix, define + round(Type{#T<:Any}, Base.Rational{Bool}, Base.Rounding.RoundingMode{:Nearest}) +before the new definition. +WARNING: New definition + round(Type{#T<:Any}, Base.Rational{Bool}, Base.Rounding.RoundingMode) at rational.jl:343 +is ambiguous with: + round(Type{#T<:Any}, Base.Rational{#Tr<:Any}, Base.Rounding.RoundingMode{:NearestTiesAway}) at rational.jl:309. +To fix, define + round(Type{#T<:Any}, Base.Rational{Bool}, Base.Rounding.RoundingMode{:NearestTiesAway}) +before the new definition. +WARNING: New definition + round(Type{#T<:Any}, Base.Rational{Bool}, Base.Rounding.RoundingMode) at rational.jl:343 +is ambiguous with: + round(Type{#T<:Any}, Base.Rational{#Tr<:Any}, Base.Rounding.RoundingMode{:NearestTiesUp}) at rational.jl:323. +To fix, define + round(Type{#T<:Any}, Base.Rational{Bool}, Base.Rounding.RoundingMode{:NearestTiesUp}) +before the new definition. +multinverses.jl +abstractarraymath.jl +arraymath.jl +simdloop.jl +reduce.jl +reshapedarray.jl +WARNING: New definition + similar(Base.ReshapedArray, Type, Any...) at reshapedarray.jl:75 +is ambiguous with: + similar(AbstractArray, Type, Integer...) at abstractarray.jl:156. +To fix, define + similar(Base.ReshapedArray, Type, Integer...) +before the new definition. +WARNING: New definition + similar(Base.ReshapedArray, Type, Any...) at reshapedarray.jl:75 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Int64, N<:Any}}) at abstractarray.jl:159. +To fix, define + similar(Base.ReshapedArray, Type, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Base.ReshapedArray, Type, Any...) at reshapedarray.jl:75 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Integer, N<:Any}}) at abstractarray.jl:158. +To fix, define + similar(Base.ReshapedArray, Type, Tuple{Vararg{Integer, N<:Any}}) +before the new definition. +bitarray.jl +intset.jl +dict.jl +set.jl +iterator.jl +build_h.jl +version_git.jl +osutils.jl +c.jl +io.jl +iostream.jl +iobuffer.jl +char.jl +ascii.jl +string.jl +strings/types.jl +strings/basic.jl +strings/search.jl +strings/util.jl +strings/io.jl +unicode.jl +unicode/UnicodeError.jl +unicode/types.jl +unicode/checkstring.jl +unicode/utf8.jl +unicode/utf16.jl +unicode/utf32.jl +unicode/utf8proc.jl +parse.jl +shell.jl +regex.jl +pcre.jl +show.jl +base64.jl +libc.jl +libdl.jl +env.jl +intfuncs.jl +nullable.jl +libuv.jl +uv_constants.jl +event.jl +task.jl +lock.jl +stream.jl +socket.jl +filesystem.jl +process.jl +multimedia.jl +grisu.jl +methodshow.jl +floatfuncs.jl +math.jl +float16.jl +cartesian.jl +multidimensional.jl +WARNING: New definition + _internal_checkbounds(AbstractArray{#T<:Any, 1}, Union{Base.Colon, AbstractArray, Number}) at multidimensional.jl:207 +is ambiguous with: + _internal_checkbounds(AbstractArray, AbstractArray{Bool, 1}) at abstractarray.jl:140. +To fix, define + _internal_checkbounds(AbstractArray{T<:Any, 1}, AbstractArray{Bool, 1}) +before the new definition. +WARNING: New definition + _internal_checkbounds(AbstractArray{#T<:Any, 1}, Union{Base.Colon, AbstractArray, Number}) at multidimensional.jl:207 +is ambiguous with: + _internal_checkbounds(AbstractArray, AbstractArray{Bool, N<:Any}) at abstractarray.jl:139. +To fix, define + _internal_checkbounds(AbstractArray{T<:Any, 1}, AbstractArray{Bool, N<:Any}) +before the new definition. +permuteddimsarray.jl +primes.jl +reducedim.jl +ordering.jl +collections.jl +sort.jl +version.jl +gmp.jl +mpfr.jl +combinatorics.jl +hashing2.jl +dSFMT.jl +random.jl +printf.jl +meta.jl +Enums.jl +serialize.jl +channels.jl +multi.jl +workerpool.jl +pmap.jl +managers.jl +asyncmap.jl +loading.jl +mmap.jl +sharedarray.jl +WARNING: New definition + similar(Base.SharedArray, Any, Tuple{Vararg{Int64, N<:Any}}) at sharedarray.jl:433 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Int64, N<:Any}}) at abstractarray.jl:159. +To fix, define + similar(Base.SharedArray, Type, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Base.SharedArray, Any, Tuple{Vararg{Int64, N<:Any}}) at sharedarray.jl:433 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Integer, N<:Any}}) at abstractarray.jl:158. +To fix, define + similar(Base.SharedArray, Type, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Base.SharedArray, Any) at sharedarray.jl:434 +is ambiguous with: + similar(AbstractArray, Type) at abstractarray.jl:153. +To fix, define + similar(Base.SharedArray, Type) +before the new definition. +WARNING: New definition + similar(Base.SharedArray, Any) at sharedarray.jl:434 +is ambiguous with: + similar(AbstractArray{#T<:Any, N<:Any}, Tuple{Vararg{Integer, N<:Any}}) at abstractarray.jl:154. +To fix, define + similar(Base.SharedArray{#T<:Any, N<:Any}, Tuple{Vararg{Integer, N<:Any}}) +before the new definition. +WARNING: New definition + similar(Base.SharedArray, Any) at sharedarray.jl:434 +is ambiguous with: + similar(AbstractArray{#T<:Any, N<:Any}, Integer...) at abstractarray.jl:155. +To fix, define + similar(Base.SharedArray{#T<:Any, N<:Any}, Integer) +before the new definition. +WARNING: New definition + similar(Base.SharedArray, Any) at sharedarray.jl:434 +is ambiguous with: + similar(AbstractArray, Type, Integer...) at abstractarray.jl:156. +To fix, define + similar(Base.SharedArray, Type) +before the new definition. +datafmt.jl +deepcopy.jl +interactiveutil.jl +replutil.jl +test.jl +i18n.jl +initdefs.jl +Terminals.jl +LineEdit.jl +REPLCompletions.jl +REPL.jl +client.jl +util.jl +linalg.jl +WARNING: New definition + size(Base.LinAlg.LowerTriangular, Any...) at linalg/triangular.jl:20 +is ambiguous with: + size(Any, Integer, Integer, Integer...) at abstractarray.jl:23. +To fix, define + size(Base.LinAlg.LowerTriangular, Integer, Integer, Integer...) +before the new definition. +WARNING: New definition + size(Base.LinAlg.UnitLowerTriangular, Any...) at linalg/triangular.jl:20 +is ambiguous with: + size(Any, Integer, Integer, Integer...) at abstractarray.jl:23. +To fix, define + size(Base.LinAlg.UnitLowerTriangular, Integer, Integer, Integer...) +before the new definition. +WARNING: New definition + size(Base.LinAlg.UpperTriangular, Any...) at linalg/triangular.jl:20 +is ambiguous with: + size(Any, Integer, Integer, Integer...) at abstractarray.jl:23. +To fix, define + size(Base.LinAlg.UpperTriangular, Integer, Integer, Integer...) +before the new definition. +WARNING: New definition + size(Base.LinAlg.UnitUpperTriangular, Any...) at linalg/triangular.jl:20 +is ambiguous with: + size(Any, Integer, Integer, Integer...) at abstractarray.jl:23. +To fix, define + size(Base.LinAlg.UnitUpperTriangular, Integer, Integer, Integer...) +before the new definition. +WARNING: New definition + size(Base.LinAlg.HessenbergQ, Any...) at linalg/hessenberg.jl:36 +is ambiguous with: + size(Any, Integer, Integer, Integer...) at abstractarray.jl:23. +To fix, define + size(Base.LinAlg.HessenbergQ, Integer, Integer, Integer...) +before the new definition. +WARNING: New definition + size(Union{Base.LinAlg.Hermitian{T<:Any, S<:Any}, Base.LinAlg.Symmetric{T<:Any, S<:Any}}, Any...) at linalg/symmetric.jl:25 +is ambiguous with: + size(Any, Integer, Integer, Integer...) at abstractarray.jl:23. +To fix, define + size(Union{Base.LinAlg.Hermitian{T<:Any, S<:Any}, Base.LinAlg.Symmetric{T<:Any, S<:Any}}, Integer, Integer, Integer...) +before the new definition. +broadcast.jl +statistics.jl +irrationals.jl +WARNING: New definition + log(Base.Irrational{:e}, Any) at irrationals.jl:130 +is ambiguous with: + log(#T<:Number, #T<:Number) at math.jl:101. +To fix, define + log(Base.Irrational{:e}, Base.Irrational{:e}) +before the new definition. +WARNING: New definition + log(Base.Irrational{:e}, Any) at irrationals.jl:130 +is ambiguous with: + log(Number, Number) at math.jl:102. +To fix, define + log(Base.Irrational{:e}, Number) +before the new definition. +WARNING: New definition + log(Base.Irrational{:e}, Any) at irrationals.jl:130 +is ambiguous with: + log(#T1<:Number, AbstractArray{#T2<:Number, N<:Any}) at operators.jl:484. +To fix, define + log(Base.Irrational{:e}, AbstractArray{#T2<:Number, N<:Any}) +before the new definition. +dft.jl +dsp.jl +sysinfo.jl +quadgk.jl +fastmath.jl +libgit2.jl +pkg.jl +stacktraces.jl +profile.jl +Dates.jl +sparse.jl +WARNING: New definition + similar(Base.SparseArrays.SparseMatrixCSC, Type{#Tv<:Any}, Tuple{Vararg{Integer, #N<:Any}}) at sparse/sparsematrix.jl:244 +is ambiguous with: + similar(AbstractArray, Type, Tuple{Vararg{Int64, N<:Any}}) at abstractarray.jl:159. +To fix, define + similar(Base.SparseArrays.SparseMatrixCSC, Type{T<:Any}, Tuple{Vararg{Int64, N<:Any}}) +before the new definition. +threads.jl +threadcall.jl +deprecated.jl +require.jl +docs/helpdb.jl +docs/helpdb/Base.jl +docs/helpdb/Dates.jl +docs/basedocs.jl +markdown/Markdown.jl +docs/Docs.jl +/Volumes/Lion/Users/jameson/Documents/julia/base/precompile.jl + diff --git a/src/gf.c b/src/gf.c index c4a930151edcdd..69a4ff2b4f2e84 100644 --- a/src/gf.c +++ b/src/gf.c @@ -744,36 +744,40 @@ struct ambiguous_matches_env { struct typemap_intersection_env match; union jl_typemap_t defs; jl_typemap_entry_t *newentry; + jl_array_t *shadowed; + int after; }; +const int eager_ambiguity_printing = 1; static int check_ambiguous_visitor(jl_typemap_entry_t *oldentry, struct typemap_intersection_env *closure0) { struct ambiguous_matches_env *closure = container_of(closure0, struct ambiguous_matches_env, match); - if (oldentry == closure->newentry) - return 0; // finished once it finds the method that was just inserted - // TODO: instead, maybe stop once we hit something newentry is definitely more specific than - + if (oldentry == closure->newentry) { + closure->after = 1; + return 1; + } union jl_typemap_t map = closure->defs; jl_tupletype_t *type = (jl_tupletype_t*)closure->match.type; jl_method_t *m = closure->newentry->func.method; jl_tupletype_t *sig = oldentry->sig; jl_value_t *isect = closure->match.ti; + if (sigs_eq(isect, (jl_value_t*)type, 1)) { + // we're ok if the new definition is actually the one we just + // inferred to be required (see issue #3609). ideally this would + // never happen, since if New ⊓ Old == New then we should have + // considered New more specific, but jl_args_morespecific is not + // perfect, so this is a useful fallback. + return 1; + } + // we know type ∩ sig != Union{} and - // we know !jl_args_morespecific(type, sig) + // we know !jl_args_morespecific(type, sig) [before] + // or !jl_args_morespecific(sig, type) [after] // now we are checking that the reverse is true - if (!jl_args_morespecific((jl_value_t*)sig, (jl_value_t*)type)) { - if (sigs_eq(isect, (jl_value_t*)type, 1)) { - // we're ok if the new definition is actually the one we just - // inferred to be required (see issue #3609). ideally this would - // never happen, since if New ⊓ Old == New then we should have - // considered New more specific, but jl_args_morespecific is not - // perfect, so this is a useful fallback. - return 1; - } + if (!jl_args_morespecific((jl_value_t*)(closure->after ? type : sig), + (jl_value_t*)(closure->after ? sig : type))) { jl_typemap_entry_t *l = jl_typemap_assoc_by_type(map, (jl_tupletype_t*)isect, NULL, 0, 0, 0); - if (l) { - // ok, intersection is covered + if (l != NULL) // ok, intersection is covered return 1; - } jl_method_t *mambig = oldentry->func.method; if (m->ambig == jl_nothing) { m->ambig = (jl_value_t*) jl_alloc_cell_1d(0); @@ -783,15 +787,36 @@ static int check_ambiguous_visitor(jl_typemap_entry_t *oldentry, struct typemap_ mambig->ambig = (jl_value_t*) jl_alloc_cell_1d(0); jl_gc_wb(mambig, mambig->ambig); } - jl_cell_1d_push((jl_array_t*) m->ambig, (jl_value_t*) mambig); - jl_cell_1d_push((jl_array_t*) mambig->ambig, (jl_value_t*) m); + if (!closure->after) { // FIXME: this isn't supposed to be conditional + jl_cell_1d_push((jl_array_t*) m->ambig, (jl_value_t*) mambig); + jl_cell_1d_push((jl_array_t*) mambig->ambig, (jl_value_t*) m); + } + if (eager_ambiguity_printing) { + JL_STREAM *s = JL_STDERR; + jl_printf(s, "WARNING: New definition \n "); + jl_static_show_func_sig(s, (jl_value_t*)type); + print_func_loc(s, m); + jl_printf(s, "\nis ambiguous with: \n "); + jl_static_show_func_sig(s, (jl_value_t*)sig); + print_func_loc(s, oldentry->func.method); + jl_printf(s, ".\nTo fix, define \n "); + jl_static_show_func_sig(s, isect); + jl_printf(s, "\nbefore the new definition.\n"); + } return 1; // there may be multiple ambiguities, keep going } + else if (closure->after) { + // record that this method definition is being partially replaced + if (closure->shadowed == NULL) { + closure->shadowed = jl_alloc_cell_1d(0); + jl_cell_1d_push(closure->shadowed, (jl_value_t*)m); + } + } return 1; } -static void check_ambiguous_matches(union jl_typemap_t defs, - jl_typemap_entry_t *newentry) +static jl_array_t *check_ambiguous_matches(union jl_typemap_t defs, + jl_typemap_entry_t *newentry) { jl_tupletype_t *type = newentry->sig; size_t l = jl_svec_len(type->parameters); @@ -811,9 +836,12 @@ static void check_ambiguous_matches(union jl_typemap_t defs, env.match.env = NULL; env.defs = defs; env.newentry = newentry; - JL_GC_PUSH2(&env.match.env, &env.match.ti); + env.shadowed = NULL; + env.after = 0; + JL_GC_PUSH3(&env.match.env, &env.match.ti, &env.shadowed); jl_typemap_intersection_visitor(defs, 0, &env.match); JL_GC_POP(); + return env.shadowed; } static void method_overwrite(jl_typemap_entry_t *newentry, jl_method_t *oldvalue) { @@ -834,7 +862,7 @@ static void method_overwrite(jl_typemap_entry_t *newentry, jl_method_t *oldvalue } // invalidate cached methods that overlap this definition -static void invalidate_conflicting(union jl_typemap_t *pml, jl_value_t *type, jl_value_t *parent) +static void invalidate_conflicting(union jl_typemap_t *pml, jl_value_t *type, jl_value_t *parent, jl_array_t *shadowed) { jl_typemap_entry_t **pl; if (jl_typeof(pml->unknown) == (jl_value_t*)jl_typemap_level_type) { @@ -843,7 +871,7 @@ static void invalidate_conflicting(union jl_typemap_t *pml, jl_value_t *type, jl for(int i=0; i < jl_array_len(cache->arg1); i++) { union jl_typemap_t *pl = &((union jl_typemap_t*)jl_array_data(cache->arg1))[i]; if (pl->unknown && pl->unknown != jl_nothing) { - invalidate_conflicting(pl, type, (jl_value_t*)cache->arg1); + invalidate_conflicting(pl, type, (jl_value_t*)cache->arg1, shadowed); } } } @@ -851,7 +879,7 @@ static void invalidate_conflicting(union jl_typemap_t *pml, jl_value_t *type, jl for(int i=0; i < jl_array_len(cache->targ); i++) { union jl_typemap_t *pl = &((union jl_typemap_t*)jl_array_data(cache->targ))[i]; if (pl->unknown && pl->unknown != jl_nothing) { - invalidate_conflicting(pl, type, (jl_value_t*)cache->targ); + invalidate_conflicting(pl, type, (jl_value_t*)cache->targ, shadowed); } } } @@ -862,9 +890,17 @@ static void invalidate_conflicting(union jl_typemap_t *pml, jl_value_t *type, jl pl = &pml->leaf; } jl_typemap_entry_t *l = *pl; + size_t i, n = jl_array_len(shadowed); + jl_value_t **d = jl_cell_data(shadowed); while (l != (void*)jl_nothing) { - if (jl_type_intersection(type, (jl_value_t*)l->sig) != - (jl_value_t*)jl_bottom_type) { + int replaced = 0; + for (i = 0; i < n; i++) { + if (d[i] == l->func.value) { + replaced = jl_type_intersection(type, (jl_value_t*)l->sig) != (jl_value_t*)jl_bottom_type; + break; + } + } + if (replaced) { *pl = l->next; jl_gc_wb(parent, *pl); } @@ -898,11 +934,16 @@ void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method, jl_tupletyp type, tvars, simpletype, jl_emptysvec, (jl_value_t*)method, 0, &method_defs, &oldvalue); if (oldvalue) { method->ambig = ((jl_method_t*)oldvalue)->ambig; - method_overwrite(newentry, (jl_method_t*)oldvalue); + method_overwrite(newentry, (jl_method_t*)oldvalue); // note: oldvalue is unrooted here + } + else { + jl_array_t *shadowed = check_ambiguous_matches(mt->defs, newentry); + if (shadowed) { + JL_GC_PUSH1(&shadowed); + invalidate_conflicting(&mt->cache, (jl_value_t*)type, (jl_value_t*)mt, shadowed); + JL_GC_POP(); + } } - else - check_ambiguous_matches(mt->defs, newentry); - invalidate_conflicting(&mt->cache, (jl_value_t*)type, (jl_value_t*)mt); update_max_args(mt, type); JL_SIGATOMIC_END(); }