v0.1.0

JET v0.1.0

Closed issues:

• NoMethodErrorReport can have fairly lots of false positives for union-matching methods (because abstract_call_gf_by_type doesn't abstract_call matching methods using constant propagation) (#19)
• virtual_process! fails on container expression (#21)
• invalidated code cache seems to cause an internal error (#22)
• rhs local block leak into the toplevel (#23)
• virtualprocess.jl is problematic, find an alternative way to simulate toplevel execution (#26)
• toplevel function definitions with references to virtual global variables should be invalidated on their redefinition (#29)
• cached reports can get crazy when constant propagation happens (#31)
• more careful report throw-away by "constant propagated"-interpretation (#36)
• profiling performance (#39)
• false positives on kwargs method (#43)
• When returning tuples, the variables are incorrectly detected as not defined (#44)
• self-profiling result (#51)
• README should be updated (#52)
• global variable woe (#54)
• profiling performance and correctness (#61)
• benchmark tools for JET analysis (#67)
• performance problem in #65 (#71)
• analysis from method signatures (and even from a module definition) (#76)
• World age issue (#104)
• don't use Dict for local cache store (#109)
• toplevel ccall causes an type assertion error (#133)
• support configurations via file (#137)
• Errors on function definition using a global variable (#142)

Merged pull requests:

• profile on optimized typed AST (#1) (@aviatesk)
• Escape recursion (#2) (@aviatesk)
• more exception escaping (#3) (@aviatesk)
• use AbstractInterpreter interface (#4) (@aviatesk)
• type level virtual machine, enable profiling on toplevel code (#5) (@aviatesk)
• watch mode (#6) (@aviatesk)
• allow import/using (#7) (@aviatesk)
• vast improve for multiple file profilings (via include calls): (#8) (@aviatesk)
• fix location info traverse (#9) (@aviatesk)
• no hacky overwriting of typeinf_local (#10) (@aviatesk)
• turn on optimization, integrate error reports with native code cache (#11) (@aviatesk)
• filter native remarks in abstract interpretation pass: (#12) (@aviatesk)
• improved signatures (#13) (@aviatesk)
• sequential profiling on toplevel profiling: (#14) (@aviatesk)
• fix bugs and setup CI (#15) (@aviatesk)
• handle :module, improve self-reference resolution, etc (#16) (@aviatesk)
• report throw calls appropriately (#17) (@aviatesk)
• don't report in abstract_call simulated in return_type_tfunc (#18) (@aviatesk)
• try to exclude false positive NoMethodErrorReport for union-split method matching (#20) (@aviatesk)
• report locally undefined variables (slots) (#24) (@aviatesk)
• improve virtual global var assignement (#25) (@aviatesk)
• "fix" the logic to call down into NativeInterpreter's abstract interpretation logic (#27) (@aviatesk)
• invalidate code cache with references to virtual global variables on their update (#30) (@aviatesk)
• fix cache: (#32) (@aviatesk)
• exclude more false positive cases with constant propagation (#33) (@aviatesk)
• delete InvalidBuiltinnCallErrorReport when it turns out to be false positive by constant propagation (#34) (@aviatesk)
• special case splat call printing (#35) (@aviatesk)
• throw away report that is lineage of current constant-propagated frame (#37) (@aviatesk)
• rm reconstruction of cached reports, just force inference on "errorne… (#38) (@aviatesk)
• power up virtual process (#40) (@aviatesk)
• virtual global variable powerup (#41) (@aviatesk)
• power up abstract interpretation (#42) (@aviatesk)
• try to handle multiple decls and assignments (#45) (@aviatesk)
• wip: power up virtualprocess, retry #26 (#46) (@aviatesk)
• alternative for #46, hybrid approach: (#47) (@aviatesk)
• don't abstract away toplevel eval calls (#48) (@aviatesk)
• handle module usage in ConcreteInterpreter (#49) (@aviatesk)
• handle errors in concrete interpretation (#50) (@aviatesk)
• add NoFieldErrorReport (#53) (@aviatesk)
• try to invalidate erroneous code cache created by native compiler (#55) (@aviatesk)
• global variable woes end game (#56) (@aviatesk)
• bump LoweredCodeUtils (#57) (@aviatesk)
• invalidate internal code cache anyway when JET hasn't analyzed it yet (#58) (@aviatesk)
• setup AnalysisParams and allow arbitrary kwargs for each JETInterpreter params (#59) (@aviatesk)
• try to find a right way to throw away false positive reports (#60) (@aviatesk)
• rm temporary patch (#62) (@aviatesk)
• remove no-longer needed self profiling switches (#63) (@aviatesk)
• re-integrate JET analysis with native code cache logic (#65) (@aviatesk)
• refine interactive utils (#66) (@aviatesk)
• cache reports per-frame basis (#68) (@aviatesk)
• easy maintain of monkey patches (#70) (@aviatesk)
• register callbacks to invalidate JET caches (#72) (@aviatesk)
• special case UndefKeywordError (#73) (@aviatesk)
• minor performance optimization, avoid splat calls (#74) (@aviatesk)
• report DivideError when the second argument is constant zero (#77) (@aviatesk)
• enhance benchmark, integrated performance tracking (#78) (@aviatesk)
• dummy benchmark (#79) (@aviatesk)
• actually enable integrated performance tracking (#80) (@aviatesk)
• update benchmark comment (#81) (@aviatesk)
• update to JuliaLang/julia#38820 (#83) (@aviatesk)
• asserts there's no configuration conflicts (#84) (@aviatesk)
• watch w/ Revise (#85) (@aviatesk)
• make isexpr type-stable (#86) (@aviatesk)
• implement our own cache type, remove typeinf_edge monkey patch (#87) (@aviatesk)
• misc improvements (#89) (@aviatesk)
• try to address #75, fix performance problem (#90) (@aviatesk)
• don't cache reports when NativeInterpreter doesn't cache result (#91) (@aviatesk)
• update to latest compiler code, ease monkey patch (#92) (@aviatesk)
• disable optimize, may speed up (#93) (@aviatesk)
• missing ignorelimited handling (#94) (@aviatesk)
• try CI on v1.6 (#95) (@aviatesk)
• re-enable optimization step for JETInterpreter (#96) (@aviatesk)
• temporal remedy for #75, dirty fix of performance problem (#97) (@aviatesk)
• use dispatch to get a type (#98) (@aviatesk)
• abstracts hash/== pattern with @withmixedhash (#99) (@aviatesk)
• more typing (#100) (@aviatesk)
• package analysis, enter analysis from method signature (#101) (@aviatesk)
• turn on inference on throw blocks (#103) (@aviatesk)
• expand macros before checking for :toplevel/:module expressions (#107) (@aviatesk)
• fixes #104 (#108) (@aviatesk)
• fixes #109, mimic the native implementation of local cache (#110) (@aviatesk)
• update AbstractInterpreter interfaces (#115) (@aviatesk)
• more robust abstract global variable assignment (#119) (@aviatesk)
• ban "virtual" global variable, use "abstract" terminology instead (#120) (@aviatesk)
• report invalid invoke calls (#122) (@aviatesk)
• follow #122, don't report duplicated error propagated from invoked call (#123) (@aviatesk)
• fix #114, add special cased analysis pass for task parallelism (#124) (@aviatesk)
• refactor configuration interfaces (#125) (@aviatesk)
• report NonBooleanCondErrorReport for erroneous union type (#126) (@aviatesk)
• add initial documentation (#127) (@aviatesk)
• refactor logging story (#128) (@aviatesk)
• eliminates hacky overloads ! (#129) (@aviatesk)
• update to JuliaLang/julia#39972 (#131) (@aviatesk)
• improve internal docs and interfaces (#132) (@aviatesk)
• fix #133, don't cache nor optimize toplevel frame (#134) (@aviatesk)
• quote constant abstract global value (#136) (@aviatesk)
• configurable concretization strategy (#138) (@aviatesk)
• fix #137, support .JET.toml configuration file (#140) (@aviatesk)
• fix #142, global variable woe, again (#143) (@aviatesk)
• run CI on v1.6 (#144) (@aviatesk)
• self-profiling results at 0ae4d76 (#145) (@aviatesk)
• allows whatever pattern at-capture accepts (#146) (@aviatesk)
• refactor for easier inspection of virtual_process! result (#147) (@aviatesk)