bronsa/cinc

[MOVED] Clojure compiler in Clojure

cinc's Issues

add type based method validation

remove :env where not needed

currently every node has an :env node, this is for consisntency but many nodes (such as :bindings) will never need it and having it makes the ast incredibly long and unreadable

License

There doesn't seem to be one.

optimize primitive calls

implement primitive interfaces/invoke via invokePrim

split infer-tag in infer-tag and infer-tag-aggressive

validate loop locals

don't consider untagged nodes in infer-tag

(if x "foo" ((fn [] (throw (Exception. ""))))) should get tagged as String, propagate :untagged/untyped

Don't change args' tag

Use :cast instead

make case work

Add sane error reporting

Right now we use mostly :pre to report errors for ease of development.

Need to switch to ex-info everywhere and report line/column info aswell

implement deftype/reify

Better documentation for validate/infer-tag/analyze-host-expr passes

Describe what they dissoc/assoc, the new nodes etc

emit bridge methods for deftype

fix classloader

get rid of clojure namespaces in analysis

there's no need to use them for the analysis, should revert to use an atom+map like original CinC and clojurescript

deftype* analysis is tricky

currently deftype expands to something like (let [](deftype* x ..) (import ns.x) ns.x)

Compiler.java can analyze this because the deftype gets build during analysis, completing analysis and emission.

Need to figure out a way to handle this in order not to get a ClassNotFoundException

move the constant check to an optional pass

remove all the (if const? (-analyze :const form env type) ..) instances and achieve the same results using an optional pass over the produced ast

Create an "add-children" pass

As mentioned in http://dev.clojure.org/display/design/AST+children Rich has a requirement that the AST be walkable in a "generic" way, using a :children attribute of each node.

Unfortunately, keeping children up to date while doing a bunch of transformations is difficult, so the best thing to do would just be to add a generic "add-children" pass which is always (optionally?) executed at the end of analysis.

add tests

fix letfn local redefinition

the hygienic transform makes (letfn (a [] 1) (b ) (a [] 2)) blow up instead of returning 2

compile efficient instanceof when possible

Is this analysis correct?

The tag for the first :arg is [C (array of Class), which seems suspicious.

user=>(pprint (ana/analyze '(java.lang.String/valueOf (+ 1 1)) {}))
{:tag java.lang.String,
:args
[{:tag [C,
:op :invoke,
:form (+ 1 1),
:env
{:file
"C:\Users\joel-cohen\AppData\Local\Temp\form-init7760639548724569008.clj",
:line 1,
:column 49,
:context :expr},
:meta
{:tag clojure.lang.IPersistentMap,
:op :const,
:env
{:file
"C:\Users\joel-cohen\AppData\Local\Temp\form-init7760639548724569008.clj",
:context :expr},
:type :map,
:literal? true,
:form {:column 49, :line 1}},
:fn
{:form +,
:env
{:file
"C:\Users\joel-cohen\AppData\Local\Temp\form-init7760639548724569008.clj",
:context :expr},
:op :var,
:name +,
:ns clojure.core,
:assignable? false,
:var #<Var@2dcf4363:
#<core$PLUS clojure.core$PLUS@47229edd>>},
:args
[{:tag java.lang.Long,
:op :const,
:env
{:file
"C:\Users\joel-cohen\AppData\Local\Temp\form-init7760639548724569008.clj",
:context :expr},
:type :number,
:literal? true,
:form 1}
{:tag java.lang.Long,
:op :const,
:env
{:file
"C:\Users\joel-cohen\AppData\Local\Temp\form-init7760639548724569008.clj",
:context :expr},
:type :number,
:literal? true,
:form 1}]}],
:method valueOf,
:op :static-call,
:class java.lang.String,
:form (. java.lang.String (valueOf (+ 1 1))),
:env
{:file
"C:\Users\joel-cohen\AppData\Local\Temp\form-init7760639548724569008.clj",
:line 1,
:column 23}}
nil

fix sorted collections handling

this is currently broken in the clojure compiler.

complete emit-form pass

remove unnecessary boxing/unboxing

This happens for primitive tagged functions that don't have any prim interface.

support array tags

Preserve metadata everywhere

Currently metadata is only attached to the :form node for most of the AST nodes, we need to put it in a node everywhere

fix closures emission

Add :tag, :line, :column info

prevent passes to do the work multiple times

There are some passes that are repeated until nothing more can be done, those passes re-run everywhere they have already run recomputing the already-computed results, we should just leave there what's already there and only do the work that's needed

add support for intrinsics

clojure/clojure@e929787

Improve documentation

Add local type inference

so that we don't reflect for (let [a "foo"] (.toString a))

get intrinsic predicates to work

handle primitive types

mostly unbox on let/number literal

enhance performance of host-interop validation

better cast/box handling

Currently cast/box handling is handled both by the box pass and in emit.

The cast/box info should only be set by the box pass

rewrite method-matching bits of validate

The current implementation is:

• horribly complex
• dog-slow
• partially-broken

remove need for :eval

We should remove any usage of :eval, wrapping the top-level form with ((fn* [] ..)) in the eval function thus removing any need for an interpreted eval

Is there a performance cost?
Do I care?

Support clojurescript-like field accessors

(.-field obj)

emit load() method in wrapping fn