WIP: redesign closures, then generic functions #13412

now handles out-of-scope method adds more generally by just specializing captured values into the AST. also passes the keywordargs test fix capturing of static parameters. for now, treats them like normal variables bug fix: forgot to apply cl-convert to declared types in assignments more efficient closure conversion of some single-assigned variables don't generate constructor functions for closure types this is much more efficient in multiple respects. before, we spent too much time inserting into the Type method table.

this eliminates a duplicate copy of inference0.ji that was ending up in inference.ji and sys.so.

…st-perf give an error for trying to add a method to a function argument remove builtin definition of jl_box_type; can be moved to boot.jl don't allocate MethodTable for abstract types fix incorrect call to func_for_method/jl_instantiate_staged use os test macro instead of `if` in core tests

- restore "must be imported to be extended" error - error for trying to add a method to a non-singleton deprecation warning for overloading `call`

other functions continue to use first argument this seems to give generally better performance

this is a fairly effective heuristic for reducing unnecessary specialization on functions of many different types passed as arguments. higher-order functions that actually do work call their argument function(s), and so still get specialized.

…gument list doesn't need to be copied as often [ci skip]

more consistently use f+args type tuples in inference and reflection

manual and devdocs updates for function change document how I made this branch passably efficient [ci skip]

Precompile depended on kwsorter name

This error is not necessary. fix a regression (jb/functions) in macroexpand of global function defs improve error reporting in `functionloc`

this is applicable to master too, but seems much harder to trigger there

this avoids blowup from the doc system

…onvert this affects conditional definitions at the top level, e.g. if cond else type Foo; end g{T<:Foo}(x) = 0 end we don't want to move the method def above the type def

Some function-valued argument slots will now be specialized as `Any`, and we need to allow those to match Refs in cfunction. This was triggered by the Gtk.jl tests. undo some changes that aren't actually needed anymore restore some commented-out tests

Moves the sparam information from the AST to the LambdaInfo so that it is more accessible to method dispatch (among other uses)

…time this marks the low bit of the fptr to indicate to the frontend which jl_fptr_t calling convention should be used

and fix a method definition mistake in base which defined convert(T, Float64) where T could be a UnionType instead of a leaftype

…ne tvar

…hat appear in the type signature directly

since the sparams env can now be passed directly into a function as an extra argument, linfo->unspecialized can (usually) be shared among all instances of a function (the only exception being the presence of intrinsics that are expecting to be able to call static_eval); the implementation of jl_instantiate_staged can be greatly simplified; and code_llvm can safely generate code for any function (via unspecialized), without corrupting the cached AST info

x86 doesn't guarantee function-pointer alignment, and adding the gcc attribute to force it is probably not portable it shouldn' be particularly critical from a performace perspective anyhow

Currently `#unused#`, but can be switched to `_` easily. Also only works for arguments so far; used for arguments marked `::T`. Also use the dedicated name `#self#` for the closure self argument.

fix #14610, closures inside argument type decls

This was mostly due to sending a fresh copy of a closure's type every time. Now reused using the same mechanism as LambdaStaticData. Also, toplevel named functions are assumed present on all processors.

also generally improve type serialization It turns out this requires the serializer to preserve the identity of TypeVars, since otherwise TypeName.primary doesn't have the right structure and field types don't get populated correctly when the type is instantiated. Since TypeVar identity does actually matter, we have to consider them mutable for now.

``` MethodError: `setindex!` has no method matching setindex!(::Core.#typeof, ... ```

this fixes Rif.jl tests

this moves the lowest-level Array constructor to Core and refactors a bit of other code to remove some other constructors from the Core.Inference image the net result is that only a single method-overwritten warning remains from the process of building the sysimg.jl file: WARNING: Method definition (::Type{#T<:Any})(Any) in module Inference at essentials.jl:21 overwritten in module Base at essentials.jl:21.

longer timeout in sigint test `T()` should not be considered a `convert` call in replutil test.

[ci skip]

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

WIP: redesign closures, then generic functions #13412

WIP: redesign closures, then generic functions #13412

Commits on Jan 28, 2016