Clojure JIRA

[CLJS-509] Spurious warning about symbol not being a protocol

Tue, 21 May 2013 09:22:44 -0500

"lein cljsbuild" generates "Symbol X is not a protocol" warning. The following code snippet reproduces the issue. Renaming "my.foo" namespace to "foo" compiles with no warning.

;; file:: foo.cljs
(ns my.foo)

(defprotocol IFoo
(bar[this]))

;; file: fubar.cljs
(ns fubar
(:require
[my.foo :as foo]))

(deftype FuBar []
foo/IFoo
(bar [this]))

cljs output:
WARNING: Symbol foo/IFoo is not a protocol at line 5 src/fubar.cljs

[CLJS-508] Missing IReduce implementations and typo in clojure.core.reducers/append!

Thu, 23 May 2013 03:10:17 -0500

1) IReduce protocol is missing implementation for array and List.
2) append! uses (.add array), while the correct array method name is push

Patch attached.

Note: what is your experience with array.push performance? ClojureScript reducers/foldcat uses arrays for append! / cat implementation. My experience was that (into [] ...) using conj! and TransientVector was at least 5 times faster than reducers/foldcat using array and push. The reason is probably inefficient push implementation in Chrome/V8

[CLJS-507] Persistent Data Structure Benchmark

Mon, 20 May 2013 14:35:42 -0500

Put together an easy to run series of persistent data structure benchmarks that can be easily run. For example we would like to submit to this Mozilla ticket http://bugzilla.mozilla.org/show_bug.cgi?id=874174

[CLJS-506] Flag to disable minification in advanced mode

Sun, 19 May 2013 10:11:15 -0500

Problem:
Some code has different semantics when compiled in advanced mode.
Clojurescript tries to minimize those cases, but examples are usage of aget or forgotten externs files.
There exits closure compiler options to generate names based on original expressions, even with advanced optimizations.
However, there exists no clojurescript compiler option for that.

Proposal:
Add a :debug compiler option to clojurescript, which can be set to true to turn the following closure compiler options on:

generatePseudoNames true
anonymousFunctionNaming AnonymousFunctionNamingPolicy/UNMAPPED

Attached patch implements this, as a result the compiled test suite is indeed quite readable.

[CLJS-505] reduce-kv doesn't work on this dataset

Sun, 12 May 2013 22:49:57 -0500

reduce-kv seems to fail with certain datasets in clojurescript but works in clojure. plain reduce works in both. Test dataset and functions:

(def tst '{0 (0.16245458703559382 0.16299961144753652), 1 (0.17095488518209803 0.1662484375243468), 2 (0.19709700082585824 0.1876248353737042 0.18162592547515274), 3 (0.21941419798490325 0.21807914100386067 0.21533585716040135 0.21307519864852958 0.20703453840254027 0.20459935129415552), 4 (0.2254558759699653 0.22553167887455705 0.2234426184638531), 5 (0.23427611508459756 0.2325434766605363 0.22990656317710662 0.22720478209110223), 6 (0.236386202300682 0.237142940385559 0.23819488667547528 0.23768692982616965 0.23701568705350426 0.2519226069678777), 7 (0.23496439825060444 0.2366135730772095 0.2358487071572212 0.2343505595436482 0.2339754113241729 0.23574632954272087 0.2342899279492302 0.23394402094793673 0.2253325456308313 0.23115349467838542 0.23764956541775945 0.24569178483873644 0.24935940319340053), 8 (0.20547261591662125 0.20726089154784122 0.21592818189465432 0.21750737743637422), 9 (0.18799738410585773 0.195400717149256 0.19631498833296726), 10 (0.1719302696659648 0.17805792401151166 0.18237267730425885), 11 (0.1623645568284537 0.16481390708298796 0.16716904262359314), 12 (0.16156804839942243 0.16211838120784386), 13 (0.16995648347966535 0.16559349825186068), 14 (0.19176771652550495 0.17696322624338934), 15 (0.23973485828855146 0.22420582245618542 0.2145975801770993 0.20208630026741867), 16 (0.2946896009888785 0.28676176338007714 0.28325454941805994 0.2716914099321759 0.26202250017945194 0.25452401319317824 0.2458771184353157), 17 (0.33300741045445653 0.3282046117335755 0.32330639472087175 0.3191873692036449 0.31290612056170736 0.30418343504691503 0.3004101566486822), 18 (0.341869650592079 0.34431149263906713 0.3457698150448536 0.34421452862514235 0.3429726966458358 0.3388988973880783 0.33579154357727864), 19 (0.2968748091051211 0.3023852506442652 0.3121637065261914 0.31141190562184173 0.32205821745972246 0.32898706631919056 0.33322752162957553 0.3396066565159988), 20 (0.2317683974879252 0.24538548478582375 0.2645130722935203 0.27362218406430894), 21 (0.20128274621982342 0.21819083560963268), 22 (0.1732991500114435 0.1811216605973363 0.19151484878018085), 23 (0.16575238432187128)})

; this returns nil in clojurescript, returns a sorted dataset in clojure.
(defn sortpi [pi]
(reduce-kv (fn [c k v] (assoc c k (sort v))) {} pi))

(sortpi tst)

; this version works in both clojurescript and clojure:
(defn sortpi2 [pi]
(reduce (fn [c [k v]] (assoc c k (sort v))) {} pi))

(sortpi2 tst)

[CLJS-504] Empty arrays and strings don't seq as nil

Tue, 7 May 2013 05:47:14 -0500

This is in CLJS v. 0.0-1803

The original symptom was that these objects didn't round-trip properly:

cljs.user=> (js->clj (clj->js {}))
{"" nil}

A little more digging shows the underlying issue:

cljs.user=> (seq (array)) 
(nil)

The same issue, with the same fix, exists for strings, so I'm including that here as well.

[CLJS-503] v8 penalizes coercive nil?

Sat, 4 May 2013 11:59:00 -0500

We check for nil coercively with != and = because we want to handle both JavaScript null and undefined. These operations are slower than !== and ==. We would like to fix this but we can't simply make nil? not be coercive. The persistent data structures rely on this because they reach into JS Arrays that been allocated with a certain size. However in JS the empty slots are filled with undefined and null requiring the more expensive coercive nil? check.

Making nil? non-coercive seems to bring less of performance boost in WebKit/Firefox Nightlies, but v8 is still the king and everyone seems to be moving towards it performance wise.

One issue with making nil? non-coercive is that undefined will then fall through many of the core library functions. This means that users will need to be more careful in interop scenarios.

[CLJS-502] add with-redefs

Wed, 8 May 2013 00:33:53 -0500

This is helpful in JVM Clojure for replacing vars for testing purposes (think mocks/stubs).

adding per discussion w/ David Nolen in #clojure IRC

[CLJS-501] add boolean coercion fn

Sun, 28 Apr 2013 22:59:38 -0500

we often type-hint return values as boolean when they are not, we should instead provide a boolean coercion fn like Clojure has.

[CLJS-500] Code Size Issue - Constructors

Sat, 4 May 2013 12:01:36 -0500

When compiling something like spectral norm http://github.com/swannodette/cljs-stl/blob/master/src/cljs_stl/spectral/demo.cljs where no ClojureScript data structures are used we still see many constructors in the advanced compiled output. The total KLOC of pretty printed advanced compiled code using master is ~3800.

Quick testing shows that the following ctors are present in spectral norm:

PersistentTreeMap
RedNode
BlackNode
PersistentTreeMapSeq
TransientHashMap
PersistentHashMap
ArrayNodeSeq
NodeSeq
HashCollisionNode
ArrayNode
BitmapIndexedNode
TransientArrayMap
PersistentArrayMap
ObjMap
NeverEquiv
TransientVector
ChunkedSeq
PersistentVector
VectorNode
ChunkedCons
ArrayChunk
ChunkBuffer
LazySeq
Keyword
Cons
EmptyLIst
List
IndexedSeq

We removed the runtime function dependency of cljs.core.PersistentTreeSet/EMPTY, all ctors related to PTSs disappeared.

Removing the runtime constructions of the other EMPTY collections seems to have no further effect on code size, probably because we have avoided dependencies elsewhere.

[CLJS-499] Reassess ObjectMap vs. PersistentArrayMap

Mon, 20 May 2013 07:59:37 -0500

Here are some benchmarks after performance improvements have been applied to PersistentArrayMap in master:

ObjMap vs PersistentArrayMap 1 entry -lookup, http://jsperf.com/ojbmap-vs-persistentarraymap-lookup-1
ObjMap vs PersistentArrayMap 3 entry -lookup, http://jsperf.com/objectmap-vs-persistentarraymap-3-lookup
ObjMap vs PersistentArrayMap 7 entry -lookup, http://jsperf.com/objmap-vs-persistentarraymap-7-lookup

For the smallest sizes PAMs are nearly identical in performance to OMs, as we start nearing the PHM threshold PAMs are nearly 2X faster on WebKit Nightly, and nearly 3X faster on the latest Chrome. Only Firefox Nightly lags behind for lookup times at larger sizes.

ObjMap vs PersistentArrayMap assoc empty, http://jsperf.com/objmap-vs-persistentarraymap-assoc-empty
ObjMap vs PersistentArrayMap assoc 3kv, http://jsperf.com/objmap-vs-persistentarraymap-assoc-3
ObjMap vs PersistentArrayMap assoc 7kv, http://jsperf.com/objmap-vs-persistentarraymap-assoc-7kv

Again we see nearly identical (or much better) performance at small sizes and much better performance for PAMs as we approach the PHM threshold.

[CLJS-498] Reassess ObjectMap vs. PersistentArrayMap

Thu, 25 Apr 2013 11:46:20 -0500

On V8, PAMs are competitive with OMs. On other browsers the performance doesn't look as good but this is probably due to the higher order code in array-map-index-of. We should remove the higher order code and more closely follow the Java PAM implementation which has different lookup loops for the different cases.

[CLJS-497] Constant literal optimization

Thu, 25 Apr 2013 11:44:36 -0500

We should optimize constant literals, in particular keywords. This optimization means that we will have to decide whether to make identical? slower by testing for keywords (this means it's probably a bad idea to continue to inline it) or to provide a special keyword-identical? that does the right thing.

[CLJS-496] better implementation of char function

Wed, 24 Apr 2013 20:09:49 -0500

There are a number of compatibility functions that are currently defined as identity functions. Among these, char

Suggested better implementation for char:

(defn char [code]
(.fromCharCode js/String code))

rather than current

(defn char [x] x)

(not sure of compatibility with node)

[CLJS-495] New undefined? macro that safely handles undeclared variables

Thu, 18 Apr 2013 17:15:51 -0500

The current `undefined?` function will blow up with a JavaScript reference error if you pass it an undeclared variable.

It'd be nice to have a way to test if a JavaScript variable has been declared.
My use case is writing a ClojureScript library that extends cljs protocols to JavaScript things.
I'd like to write

(when-not (undefined? js/jQuery)

...)

to extend-type jQuery when jQuery is around.

[CLJS-494] -lookup method call inside get macro and keyword invoke

Sun, 14 Apr 2013 17:57:38 -0500

I noticed that -lookup method is called incorrectly at two places

There are two -lookup methods defined for ILookup:

cljs/cljs/core.cljs:198
(defprotocol ILookup
(-lookup [o k] [o k not-found]))

clj/cljs/core.clj:426
(defmacro get
([coll k]
`(-lookup ~coll ~k nil))
([coll k not-found]
`(-lookup ~coll ~k ~not-found)))

As you see, macro (get foo bar) never calls first method. In first case it supplies default argument (instead calling method with 2 arguments).

Same for IFn and keywords:

(deftype Keyword [k]
IFn
(invoke [_ coll]
(when-not (nil? coll)
(let [strobj (.-strobj coll)]
(if (nil? strobj)
(-lookup coll k nil)
(aget strobj k)))))

[CLJS-493] get should accept any type the same way Clojure JVM does

Fri, 5 Apr 2013 21:30:57 -0500

The following throws instead of returning nil:

(get 42 :anything)

[CLJS-492] avoid producing unnecessary calls to next in emit-apply-to

Fri, 5 Apr 2013 21:30:39 -0500

A function like

(defn bar [a b c d e f g h i j & more])

currently receives a cljs$lang$applyTo property of the following form:

function (arglist__4466) {
    var a = cljs.core.first(arglist__4466);
    var b = cljs.core.first(cljs.core.next(arglist__4466));
    var c = cljs.core.first(cljs.core.next(cljs.core.next(arglist__4466)));
    var d = cljs.core.first(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466))));
    var e = cljs.core.first(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466)))));
    var f = cljs.core.first(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466))))));
    var g = cljs.core.first(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466)))))));
    var h = cljs.core.first(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466))))))));
    var i = cljs.core.first(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466)))))))));
    var j = cljs.core.first(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466))))))))));
    var more = cljs.core.rest(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(cljs.core.next(arglist__4466))))))))));
    return bar__delegate(a, b, c, d, e, f, g, h, i, j, more);
}

The forthcoming patch changes that to

function (arglist__4460) {
    var a = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var b = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var c = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var d = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var e = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var f = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var g = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var h = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var i = cljs.core.first(arglist__4460);
    arglist__4460 = cljs.core.next(arglist__4460);
    var j = cljs.core.first(arglist__4460);
    var more = cljs.core.rest(arglist__4460);
    return bar__delegate(a, b, c, d, e, f, g, h, i, j, more);
}

The included benchmark seems to demonstrate a substantial reduction in {apply} overhead on V8 for a function with 10 positional arguments preceding the rest arg and a less substantial reduction for a function with 2 positional arguments, as one would expect. The other benchmark entries for {apply} remain in the same ballpark ({list} actually produces the same compilation output with or without the patch; {+} is changed, but only slightly).

[CLJS-491] subvec should avoid creating layered Subvecs

Fri, 5 Apr 2013 21:30:18 -0500

cljs.core/subvec (or rather build-subvec, the implementation detail behind it) currently fails to check whether its vector argument is already a Subvec and, if so, base the new Subvec off the original regular vector. The Clojure implementation does perform the unwrapping.

The forthcoming patch fixes this and includes a basic test.

[CLJS-490] cljs.closure/get-upstream-deps* should use RT/baseLoader instead of the TCCL

Mon, 25 Mar 2013 10:12:47 -0500

get-upstream-deps* currently uses the context classloader for the current thread, which causes issues when called from within a clojure runtime that has the intended classloader bound to Compiler.LOADER. Is there a specific reason to use the TCCL directly, or would calling RT.baseLoader suffice here? I'm attaching a patch that uses baseLoader instead.

[CLJS-489] Browser-REPL automation & usability enhancements

Sat, 30 Mar 2013 09:24:26 -0500

The current implementation of browser-REPL yields a number of usability problems:

only one browser-REPL can be used at a time due to globals used to track REPL state
Browser-REPL currently involves two web servers: the one you're serving your app from, and the one that the REPL itself uses
- This makes setup difficult in the interactive case — especially for newcomers, the less experienced, or the tired
- Perhaps more significantly, coordinating the two servers and their associated state is less than easy if one wants to automate the browser-REPL for testing of DOM-related cljs code

Attached is a patch that addresses these issues:

Multiple concurrent browser-REPLs can be safely used
The browser-REPL's HTTP server is now always-on
Replaced the custom HTTP server with com.sun.net.httpserver.* bits, which are a part of J2SE 6+, not random implementation details http://docs.oracle.com/javase/7/docs/technotes/guides/net/enhancements-6.0.html
Each browser-REPL session supports a new top-level "entry" URL that can be used to easily start the REPL in a browser or other JS runtime (i.e. you don't need to have a separate webapp running to initiate the browser-REPL connection)
The entry (and REPL) URLs are available in slots on the browser-REPL's environment, making it trivial to automate browser-REPL sessions with e.g. phantomjs or a headless chromium or etc. This pattern is implemented by a new `exec-env` function; the default is to start the REPL in phantomjs using a temporary script, but it's super-easy to use a regular browser. e.g. this will use Chrome on OS X in the background:

(cljs.repl/repl (cljs.repl.browser/exec-env
                  :exec-cmds ["open" "-ga" "/Applications/Google Chrome.app"]))

(This enhancement has been discussed previously {here|http://groups.google.com/group/clojurescript/browse_thread/thread/963d6b7334bdf61c}.)

[CLJS-488] aliased keywords do not work

Thu, 21 Mar 2013 22:05:24 -0500

The folks from Pedestal encountered this.

[CLJS-487] Make cljsc copy js sources to public directory

Sat, 16 Mar 2013 00:03:41 -0500

I'll like cljsc to copy my js sources to the public directory as it does when compiling the cljs sources and make the correct entry in the generated deps.js so that the source can be retrievable with GET without extra configuration.

[CLJS-486] Consider to export cljs.core.print-fn

Sun, 17 Mar 2013 15:10:41 -0500

External tools often have the need to redefine ClojureScript's
cljs.core.print-fn var in order to get printing in different
runtimes working. In a browser environment it is usually
redefined to console.log for example.

This works fine in whitespace and simple mode because the
cljs.core.print-fn var is accessible from the outside
environment. However, in advanced mode the cljs.core.print-fn
gets renamed and external tools can't access this var anymore.

Since it looks like redefining cljs.core.print-fn is common
task, it would make sense to add ^:export to it's meta data to
prevent the Goolge Closure Compiler from renaming it.

References:

[CLJS-485] clojure.string/replace ignores regex flags

Tue, 12 Mar 2013 10:36:36 -0500

The replace function in namespace clojure.string ignores regex flag provided in the match pattern. For example:

CLJS

clojure.string/replace "I am NOT matched" #"(?i)not " "")
=> "I am NOT matched"

CLJ

clojure.string/replace "I am NOT matched" #"(?i)not " "")
=> "I am matched"

The attached patch fixes this by parsing the m and i flags, if set, from the match object, instead of explicitly setting only "g".

[CLJS-484] defmulti compiler macro tries to throw a blank string in error case

Tue, 12 Mar 2013 10:46:27 -0500

Test case

> (defmulti foo bar {:hierarchy h})
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Throwable

with the attached patch this is
clojure.lang.ExceptionInfo: The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)

[CLJS-483] Wrap cljs.compiler/compile-file in try/catch to clarify which file failed compilation

Tue, 12 Mar 2013 10:49:37 -0500

lein-cljsbuild compiles files via cljs.closure/compile-dir which in turn calls compile-file. If one file fails to compile it can be rather hard to find out which file caused the error since the reference to the file is lost.

The patch ensures that the file is known and wraps the compile exception.

See example confusing trace:
https://gist.github.com/thheller/5103320#file-lein-cljsbuild-stracktrace-txt

And the more helpful version:
https://gist.github.com/thheller/5103320#file-better-trace-txt

[CLJS-482] Rhino REPL env prints to System/out

Thu, 14 Mar 2013 19:15:12 -0500

All non-terminal REPLs bind *out*, so printing REPL output to System/out is unexpected (and sometimes black-holed depending on the environment).

Attached patch binds *out* in place of System/out in the Rhino evaluation Context.

[CLJS-481] doseq bindings with :let not properly scoped

Thu, 11 Apr 2013 21:34:33 -0500

This seems to be a subtler version of ~~CLJS-39~~:

(let [fs (atom [])]
  (doseq [x (range 4)
          :let [y (inc x)
                f (fn [] y)]]
    (swap! fs conj f))
  (map #(%) @fs))

;; => (4 4 4 4)
;; should be (1 2 3 4)

I think this example is minimal. The bug is not present if we use a proper let.

[CLJS-480] cljs-data-readers is bound to data-readers inconsistently

Tue, 21 May 2013 10:06:43 -0500

It looks like *cljs-data-readers* is not being bound to *data-readers* where it should be.

At a minimum, cljs.repl/load-stream does not. The practical effect of this instance is that e.g. (load-file "some/cljs/file.cljs") will fail if that file or any other contains a user-defined literal tag. Similar behaviour exists elsewhere, e.g. (load-namespace 'some.cljs.ns) will not load a namespace that contains user-defined tags (I think that one is due to *cljs-data-readers* not being bound in the analyzer).

This is related to CLJS-479 insofar as it's another symptom of ClojureScript loading code in subtly different ways in multiple places.

I'm happy to do either of:

submit issues+patches fixing issues as I encounter them, or
attempt a more significant refactoring that sets up (hopefully) one and only one place where ClojureScript reads code (i.e. uses LispReader) so that behaviour can be consistent

I'm somewhat hesitant re: (2) insofar as the specific requirements of the compiler and analyzer and REPL may be divergent in ways that I'm not yet aware of, but it seems like it's worth a shot.

[CLJS-479] load-file in REPL improperly qualifies current-namespace ::keywords

Wed, 24 Apr 2013 21:49:04 -0500

This can be seen by opening a REPL and:

(load-file "cljs/ns_test/foo.cljs")

The ::foo keyword in that file is resolved improperly:

ClojureScript:cljs.user> cljs.ns-test.foo/kw
:user/foo

cljs.repl/load-stream needs to force *ns* to track *cljs-ns* so that the Clojure reader will properly resolve auto-namespacing keywords. A patch is attached that does this, ensuring that any Clojure namespaces created solely for this purpose are removed.

[CLJS-478] ClojureScript js->clj not converting

Tue, 26 Feb 2013 12:00:53 -0600

I've updated to 0.0-1586 build #22 from a much older release: 0.0-1450

I'm now geting a problem with (js->clj token) not converting token to a map; this worked before I upgraded.

token is generated by the google OAuth 2 process: "gapi.auth.authorize"

I don't think the problem is with js->clj rather something about token so it isn't recognised as a js/Object.

(println (expose token true)) gives:

access_token = ya29.AHES6ZSgnk3Ws5bB-2aDx41Bbr335hKugjZJfcNAs83d121S306fxy64
token_type = Bearer
expires_in = 3600
client_id = 52351124085.apps.googleusercontent.com
scope = https://www.googleapis.com/auth/drive.file,https://www.googleapis.com/auth/drive.metadata.readonly,https://www.googleapis.com/auth/drive.readonly
g_user_cookie_policy = undefined
cookie_policy = undefined
issued_at = 1361807171
expires_at = 1361810771

This looks ok.

however
> token

gives:

"Error evaluating:" token :as "esef.client.evidence.token"
#<TypeError: Object [object Object] has no method 'toString'>
TypeError: Object [object Object] has no method 'toString'

> (type token)

gives a blank line. I think this is why js->clj isn't converting.

> (alength token)

gives a blank line.

(.-token_type token)

Correctly gives ya29.AHES6ZSgnk3Ws5bB-2aDx41Bbr335hKugjZJfcNAs83d121S306fxy64

I haven't managed to recreate 'token' with a minimal test case but I'm fairly new to javascript. It's impractical to to include my OAuth 2 code because its tied into all my google security.
If you can suggest anything that will provide you with more info on 'token' I'll try and help.

As a work-around I manually create the MAP by explicitly reading each property, I couldn't get a list of properties.

[CLJS-477] Variable argument functions break when first vararg is undefined

Tue, 26 Feb 2013 07:45:03 -0600

If the first of the variable arguments to a vararg function is the javascript value undefined, the function behaves as though it didn't receive any variable arguments at all:

(defn f [& rest] rest)

(f 1 2 3)
;; => (1 2 3) ; correct

(f 1 js/undefined 3)
;; => (1 nil 3) ; correct

(f js/undefined 2 3)
;; => nil ; wrong

[CLJS-476] Reading a value from a module does not work if the module is def'ed

Fri, 22 Feb 2013 13:13:40 -0600

Referring to a value in a module can have a scoping issue when using the "static accessor" operator of module/VALUE_NAME. The static accessor works if the module is loaded into a local value but not if def'ed. This example uses the mmap module for Node.js, and successfully reads the PROT_READ value:

(ns stat.core)
(defn -main []
(let [m (js/require "mmap")]
(println "value: " m/PROT_READ)))
(set! main-cli-fn -main)

This correctly prints "value: 1"

However, if the value for m is def'ed instead, then the compiler assumes that the reference to m is local to the function and therefore not defined:

(ns stat.core)
(def m (js/require "mmap"))
(defn -main []
(println "value: " m/PROT_READ))
(set! main-cli-fn -main)

/Users/pag/src/test/clj/stat/target/stat.js:12836
return cljs.core.println.call(null, "value: ", m.PROT_READ)
^
ReferenceError: m is not defined
at Function.stat.core._main (/Users/pag/src/test/clj/stat/target/stat.js:12836:50)
at cljs.core.apply.b (/Users/pag/src/test/clj/stat/target/stat.js:5621:14)
at cljs.core.apply.a (/Users/pag/src/test/clj/stat/target/stat.js:5656:18)
at Object.<anonymous> (/Users/pag/src/test/clj/stat/target/stat.js:12844:17)
at Module._compile (module.js:449:26)
at Object.Module._extensions..js (module.js:467:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Module.runMain (module.js:492:10)
at process.startup.processNextTick.process._tickCallback (node.js:244:9)

In this case, the value of m.PROT_READ should have been stat.core.m.PROT_READ.

On the other hand, using . syntax fixes the scoping issue:
(ns stat.core)
(def m (js/require "mmap"))
(defn -main []
(println "value: " (.-PROT_READ m)))
(set! main-cli-fn -main)

[CLJS-475] Node.js target fails with optimizations set to :none or :whitespace

Fri, 1 Mar 2013 13:26:48 -0600

Compiling a hello world program for Node.js works fine if using optimizations of :advanced or :simple, but if using :none or :whitespace then an error will be reported for either "goog undefined" or "goog.string" undefined respectively.

The program is shown here:

(ns pr.core)
(defn -main []
(println "Hello World!"))
(set! main-cli-fn -main)

This program is in src/cljs/pr/core.cljs. The repl line used to compile is:
(cljs.closure/build "src/cljs" {:output-to "src/js/pr.js" :target :nodejs :pretty-print true :optimizations :none})

When compiled with optimizations of :none, the output is:

$ node src/js/pr.js

/Users/pag/src/test/clj/pr/src/js/pr.js:1
(function (exports, require, module, __filename, __dirname) { goog.addDependen
^
ReferenceError: goog is not defined
at Object.<anonymous> (/Users/pag/src/test/clj/pr/src/js/pr.js:1:63)
at Module._compile (module.js:449:26)
at Object.Module._extensions..js (module.js:467:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Module.runMain (module.js:492:10)
at process.startup.processNextTick.process._tickCallback (node.js:244:9)

—
When running with optimizations of :whitespace the output is:

$ node src/js/pr.js

/Users/pag/src/test/clj/pr/src/js/pr.js:493
goog.string.Unicode = {NBSP:"\u00a0"};
^
TypeError: Cannot set property 'Unicode' of undefined
at Object.<anonymous> (/Users/pag/src/test/clj/pr/src/js/pr.js:493:21)
at Module._compile (module.js:449:26)
at Object.Module._extensions..js (module.js:467:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Module.runMain (module.js:492:10)
at process.startup.processNextTick.process._tickCallback (node.js:244:9)

—
When running with optimizations of either :simple or :advanced, the output is:

$ node src/js/pr.js
Hello World!

—
I have included the two javascript output files that match the above errors.

[CLJS-474] Name every fn in CLJS sources (for debugging purposes)

Mon, 18 Feb 2013 11:22:24 -0600

As mentioned here: https://groups.google.com/forum/?fromgroups=#!topic/clojurescript/ZX6M4KXx8I8

Naming every fn in the compiled javascript functions makes it a little easier to find out whats going on when looking at a stacktrace. This patch names every function generated as fn_<ns>/<orig-name>_<line>. See example stacktrace in the discussion above.

The optional cljs snippet (https://gist.github.com/thheller/4972200) then also transforms this data and prints functions as

(pr-str name)
=> #<function cljs.core/name line:5876>

instead of dumping the javascript source on you.

The .patch has the drawback that the generated source size grows a bit (about 10% on my codebase), but advanced compilation takes care of that (although even that is still a bit larger, the closure compiler doesnt seem to strip unused function names). One could make this a compiler option if the size differences are too big.

[CLJS-473] cljs.closure/add-dep-string calls wrong munge

Tue, 19 Feb 2013 08:50:10 -0600

cljs.closure/add-dep-string calls wrong munge (Clojure one), while it should be calling cljs.compiler/munge.

The problem shows up when namespace contains a reserved js name and incremental dev build is performed.

[CLJS-471] Empty regexp causes Closure Compiler error

Thu, 25 Apr 2013 05:57:34 -0500

An empty regexp of the form #"" compiles to //, which is not an empty regexp but a comment, causing the code following the supposed regexp on the affected line to be commented out. This tends to cause compiler errors when Closure Compiler tries to parse it.

#"" should instead produce either /(?:)/ or new RegExp("").

[CLJS-470] defprotocol warnings in REPL outside of cljs.user

Wed, 13 Feb 2013 12:36:54 -0600

defprotocol warnings in REPL outside of cljs.user

[CLJS-469] Bad Exception message when multimethod has no dispatch-fn

Wed, 20 Feb 2013 15:45:22 -0600

When a multi-fn has no dispatch method for a given value the current exception string prints the cljs.core/name function instead of the actual name of the mf. Minor bug but makes it kinda hard to track down which multi-fn actually failed to dispatch.

The attached patch fixes that but directly accessing the name property of the multi-fn which is not very clean but better than the current error. AFAICT cljs doesnt have the clojure.lang.Named protocol, which would probably be cleaner.

[CLJS-468] Extend CollFold and IKVReduce to nil

Fri, 1 Mar 2013 13:24:16 -0600

This has been accepted and fixed for Clojure in ~~CLJ-1098~~

[CLJS-467] ArrayNode's kv-reduce skips certain nodes

Tue, 19 Feb 2013 09:02:49 -0600

When gaps are present in an ArrayNode's array, kv-reduce would skip nodes after the first gap due to a missing else branch.

[CLJS-466] Records are printed without namespace

Tue, 26 Feb 2013 12:23:49 -0600

When printing a Record it is currently printed without the proper namespace.

(ns dummy)
(defrecord Foo [bar])
(pr-str (Foo. "bar"))

will print as "#dummy.Foo{..." in CLJ but "#Foo{..." in CLJS.

The attached patch fixes the implementation as well as the "incorrect" test.

[CLJS-465] Point to ClojureScript instead of Clojure mailing list in README.md

Wed, 6 Feb 2013 11:35:33 -0600

Point to ClojureScript instead of Clojure mailing list in README.md

[CLJS-464] `get-in` not behaving like Clojure when accessing non-existing inner maps

Mon, 28 Jan 2013 22:39:13 -0600

In Clojurescript:
(get-in {:a {:b 1}} [:a :b :c])
=> Error: 1 is not an instance of ILookup

In Clojure:
(get-in {:a {:b 1}} [:a :b :c])
=> nil

[CLJS-463] Google Closure Class interop form (genclass)

Sat, 11 May 2013 15:17:34 -0500

Currently it's not really possible to use to the existing deftype/record to construct "classes" that interop well with Google Closure. It seems odd to ship Closure and then provide no tools for writing ClojureScript against it, especially the UI component parts. Several people have asked for this now so perhaps we really should offer the ClojureScript equivalent of genclass.

[CLJS-462] cljs.reader/read-string keyword parsing is inconsistent with clojure.core/read-string

Wed, 20 Feb 2013 08:36:21 -0600

cljs/reader.cljs:120 (def symbol-pattern (re-pattern "[:]?([^0-9/].*/)?([^0-9/][^/]*)"))
cljs/reader.cljs:330 a (re-matches* symbol-pattern token)

symbol-pattern is not consistent with clojure's interpretation of valid keywords, e.g. the following are valid keywords in clojure that are not allowed by this regex:

:0foo
:/foo/bar/baz

[CLJS-461] repeated assoc into map eventually drops meta data

Sun, 27 Jan 2013 17:31:41 -0600

When running this loop, then the map's meta is lost after 32 assocs:

(loop [i 0, m (with-meta {} {:foo :bar})]
  (when (<= i 34)
    (.log js/console i (pr-str (meta m)))
    (recur (inc i) (assoc m (str i) i))))

The last 4 lines of output read

31 {:foo :bar}
  32 {:foo :bar}
  33 nil
  34 nil

cljs.core.ObjMap/HASHMAP_THRESHOLD happens to be 32, so I guess
there is a connection.

[CLJS-460] defmulti ignores optional :hierarchy argument

Sat, 26 Jan 2013 11:09:34 -0600

When an alternative hierarchy is provided to a defmulti declaration it should be used in place of the global hierarchy for isa?-based method dispatch. However, clojurescript multimethods seem to ignore this hierarchy and always use the global hierarchy. Test case provided.

[CLJS-459] Make order in which sorted map nodes are visited by reduce-kv consistent with entry order

Sun, 27 Jan 2013 17:28:52 -0600

On master, (reduce-kv prn nil (sorted-map :foo 1 :bar 2)) prints :foo before :bar. With the forthcoming patch applied, :bar comes first.

[CLJS-458] get-in throws exception when key-list contains key that doesn't satisfy ILookup

Sat, 26 Jan 2013 11:15:03 -0600

(get-in {:a {:b 1}} [:a :b :c] :nothing-there)

cljs throws exception "Error: No protocol method ILookup.-lookup defined for type number: 1"
clj returns :nothing-there

Following snippet contains an additional (satisfies? ILookup m) test to end iteration and return no-value.
If solution looks ok, I can provide a patch.

--------

(defn get-in*
  "Returns the value in a nested associative structure,
  where ks is a sequence of keys. Returns nil if the key is not present,
  or the not-found value if supplied."
  {:added "1.2"
   :static true}
  ([m ks]
     (reduce get m ks))
  ([m ks not-found]
     (loop [sentinel lookup-sentinel
            m m
            ks (seq ks)]
       (if ks
         (if-not (satisfies? ILookup m)
           not-found
           (let [m (get m (first ks) sentinel)]
             (if (identical? sentinel m)
               not-found
               (recur sentinel m (next ks)))))
         m))))

[CLJS-457] Implement notion of "unbound", i.e. uninitialized variables, in ClojureScript to mimic Clojure's behaviour

Tue, 15 Jan 2013 11:29:52 -0600

The following REPL snippets show different behavior for "unbound" vars in cljs and clj:

--------
ClojureScript:cljs.user> (def a nil)
nil
ClojureScript:cljs.user> (def b)

ClojureScript:cljs.user> (= a b)
true
--------
user=> (def a nil)
#'user/a
user=> (def b)
#'user/b
user=> (= a b)
false
--------

As a possible solution, D. Nolen suggested that we could "simulate this by creating a Unbound type and initializing def'ed vars without init expressions to instances of it."

[CLJS-456] Function named same as ns fails

Mon, 14 Jan 2013 16:33:19 -0600

In a fresh script/repljs on clojurescript master I see the following behaviour:

ClojureScript:cljs.user> (ns foo.bar)
ClojureScript:foo.bar> (defn id [x] x)
#<
  function id(x) {
      return x;
  }
  >
  ClojureScript:foo.bar> (defn foo [] (id 42))
  #<
  function foo() {
      return foo.bar.id.call(null, 42);
  }
  >
ClojureScript:foo.bar> (foo)
  "Error evaluating:" (foo) :as "foo.bar.foo.call(null)"
  org.mozilla.javascript.EcmaError: TypeError: Cannot read property "id" from undefined (<cljs repl>#4)
      at <cljs repl>:4 (foo)
      at <cljs repl>:4 (anonymous)
      at <cljs repl>:4
 
nil
ClojureScript:foo.bar>

(https://www.refheap.com/paste/8494 in case formatting fails)

[CLJS-455] Warn on invalid js forms

Wed, 20 Feb 2013 08:35:37 -0600

The ClojureScript compiler happily accepts forms like js/Math.MAX_NUMBER and (js/Math.ceil 3.14) which is not valid Clojure code. The correct way to write these expressions in ClojureScript is (.-MAX_NUMBER js/Math) and (.ceil js/Math 3.14).

The ClojureScript analyzer should at least emit a warning when these bad forms are encountered. Preferably compilation should fail but that would probably break lots of existing code.

[CLJS-454] Instance Reader to Support Micro/Nanoseconds

Thu, 21 Feb 2013 13:22:05 -0600

Any timestamps with a greater than millisecond precision cannot be handled by the ClouseScript reader:

> cljs.reader.read_date("2012-12-30T23:20:05.066980000-00:00")
> Error: Assert failed: timestamp millisecond field must be in range 0..999 Failed:  0<=66980000<=999 (<= low n high)

Here "2012-12-30T23:20:05.066980000-00:00" is an example of an ordinary timestamp that is returned from Postgres.

ClojureScript reader interprets the nanosecond portion "066980000" as milliseconds and the check here fails:

def parse-and-validate-timestamp
...
   (check 0 ms 999 "timestamp millisecond field must be in range 0..999")

[CLJS-453] ArrayVector for small vectors

Fri, 4 Jan 2013 16:54:48 -0600

Just like we have an ArrayMap for small maps, I propose to have an ArrayVector for small vectors.

Use cases:

pair of values, e.g. coordinates, triples and other tuple values
returning multiple values from a function and subsequent destructuring in a caller fn

ArrayVector has 100x faster vector creation compared to PersistentVector.
With an ^ArrayVector hint, it offers more than 10x faster destructuring. Without it, it is still about 40% faster.

Example of such destructuring:

(defn foo [a b] 
  [(+ a b) (- a b) (* a b)])

(defn bar []
  (let [[plus minus times] ^ArrayVector (foo 1 2)]
    (str "bla bla" plus "blaah" minus)))

I've attached a patch with complete implementation of such vector, supporting all basic functionalities as well as transients. This patch also replaces default vector implementation with ArrayVector, falling back to PersistentVector for large vectors.

ArrayVector implementation can also be found at array-vec branch at https://github.com/wagjo/clojurescript/tree/array-vec

[CLJS-452] clojure.browser.net: enable WebSockets?

Sun, 20 Jan 2013 00:51:30 -0600

In https://github.com/clojure/clojurescript/blob/master/src/cljs/clojure/browser/net.cljs there's a nicely prepared support for WebSockets with the note

;; WebSocket is not supported in the 3/23/11 release of Google
;; Closure, but will be included in the next release.

is there anything preventing us from enable the support for WebSockets with the next release of ClojureScript?

patch 0001-enable-websockets.patch do just enable the functionality. No test-cases included.

[CLJS-451] keywords should be implemented as JavaScript functions

Fri, 4 Jan 2013 16:52:27 -0600

Keywords are currently implemented as JavaScript strings. This makes certain JavaScript interop situations awkward: to provide a javascript api a function that can pull data from a map, one must use #(:foo %) instead of the more natural :foo. This is confusing because ClojureScript functions are otherwise fully usable in contexts expecting JavaScript functions.

The proposed alternative is to have keywords instead be implemented as JavaScript functions that accept a map and optional default value, assuming this doesn't otherwise screw up their core functionality of providing fast equality tests, etc.

[CLJS-450] (ns) within (do) inconsistent with Clojure behaviour

Sat, 5 Jan 2013 14:05:17 -0600

An (ns) within a (do) doesn't quite work as expected at the REPL:

ClojureScript:cljs.user> (do (ns foo) (def x 42))   
nil
ClojureScript:foo> x
nil
ClojureScript:cljs.user> cljs.user/x
42

The Clojure equivalent:

user=> (do (ns foo) (def x 42))
#'foo/x
foo=> x
42

[CLJS-449] stack traces for ex-info

Sun, 23 Dec 2012 16:01:39 -0600

Currently, ex-info exceptions have no stack traces, which makes them.. much less useful.

Attached patch (0001-hack-ex-info-stacktraces.patch) is one hackish way of getting stack traces back when Error.captureStackTrace is available (at least in Chrome, presumably in Node as well).

But this seems unacceptable — all the stuff emitted for the deftype (making the constructor print as a type) gets overwritten.

Is there a better way?

Will this maybe be made irrelevant by source maps?

[CLJS-448] Support for runtime reading of tagged elements

Tue, 25 Dec 2012 13:42:53 -0600

We ned the abilty to supply custom and default tag parsers when using cljs.reader/read-string (found in src/cljs/cljs/reader.cljs) in running ClojureScript applications.

ns prefixed tags

As per the edn specification "user tags must contain a prefix component". Currently, because (name tag) is being called, the ns prefix component is dropped when looking up the tag in *tag-table*

default reader fn

Currently, there is no support for supplying a default reader fn (akin to *default-data-reader-fn* in Clojure proper).

2 issues rolled into one?

I know this may be bad practice rolling 2 issues into one, but I do not know how to formulate the separate patches that affect the same lines of code and have the apply correctly regardless of order. If I need to correct this, please advise.

Already reported?

I know this issue was already raised in CLJS-335, but from my experience with making these modifications for a running ClojureScript app, I did not come across the fns in the files mentioned in that task. I assume this is because that had more to do with compiling cljs code, but please correct me if I'm wrong.

Along those lines, is this patch not acceptable if it doesn't fix both places at once?

Approach & Naming

I followed the approach that was already in place for tag parsers, supplying register and deregister helper fns. I was a bit torn on naming because in Clojure *default-data-reader-fn* is used, but in the existing ClojureScript code they are called tag-parser. Should the "reader" vs "parser" nomenclature be unified between Clojure and ClojureScript, or are they named differently because they are fundamentally different in some way that I am missing?

[CLJS-447] Throw exception if multiple namespaces are required with the same alias

Sun, 23 Dec 2012 16:10:08 -0600

Take for example this code:

(ns foo
  (:require [views.bar :as bar]
            [model.bar :as bar]))

;; this is meant to use views.bar
(bar/update-view)

The call to update-view fails with a "Cannot call method call of undefined", which is quite confusing if you have a big list of requires at the beginning. The expected behavior would be a compile-time error.

[CLJS-446] Rhino REPL emits warnings twice

Tue, 18 Dec 2012 15:38:04 -0600

This only affects functions - functions get a second pass from the compiler in order to leverage arity information for self call optimization.

[CLJS-445] declare stopped working in the REPL

Tue, 18 Dec 2012 12:36:37 -0600

Typing a declare statement in the REPL gives an error

[CLJS-444] def issues in REPL

Tue, 18 Dec 2012 14:49:56 -0600

(def x) now fails in the REPL, this is very likely a result of ~~CLJS-397~~ and ~~CLJS-403~~

[CLJS-443] protocol dispatch performance enhancement & extend-type to nil

Wed, 20 Feb 2013 08:40:07 -0600

Currently we extend to nil to a bunch of protocols, while this was convenient for the initial implementation this has many unfortunate performance consequences. We should probably not extend nil to anything and deal with the nil value directly as is done in Clojure on the JVM. In addition we can add a special ^not-native type-hint. In critical paths this would allow us to inline calls directly to protocol implementations.

Perhaps this could also allow us to hint with ^native to inline calls to the native tables.

[CLJS-442] Lazy seqs fails to close over local vars

Wed, 19 Dec 2012 07:46:00 -0600

When executing following code

(loop [i 10
       v [0]
       v2 [0]]
  (if (pos? i)
    (let [j i
          x (map #(+ j %) v)]
      (recur (dec i) x (map #(+ j %) v2)))
    (concat v v2)))

Clojure produces

(55 55)

while Clojurescript produces

(10 55)

Forcing realization of lazy seqs produces correct output (55 55) on both environments.

(loop [i 10
       v [0]
       v2 [0]]
  (if (pos? i)
    (let [j i
          x (doall (map #(+ j %) v))]
      (recur (dec i) x (doall (map #(+ j %) v2))))
    (concat v v2)))

[CLJS-441] Require implicit 'do nodes for all blocks in AST

Fri, 21 Dec 2012 17:36:42 -0600

Discussion here: https://groups.google.com/d/topic/clojure-dev/6CVTsW1EQn4/discussion

[CLJS-440] Replace :is-loop flag in AST with distinct :loop op

Fri, 21 Dec 2012 17:12:07 -0600

Discussion here: https://groups.google.com/d/topic/clojure-dev/6CVTsW1EQn4/discussion

[CLJS-439] IEncodeClojure only works on same-context Objects

Sun, 20 Jan 2013 00:52:27 -0600

The default impl uses (identical? (type x) js/Object), but objects created in another JS context (e.g. another frame) will fail this test, since their constructor is a different js/Object. Thus js->clj is the identity on such objects.

I wonder if there are any related problems anywhere else, e.g. with protocols? This seems to be the only occurrence of js/Object.

Maybe this can be fixed by extending IEncodeClojure to object? I don't immediately see how to do that without incurring the option destructuring overhead recursively.

[CLJS-438] copy cond-> etc from 1.5

Sun, 17 Mar 2013 15:01:52 -0500

Attached patch (cljs-438-condetc.patch, 11 Dec 2012) copies cond->, cond->>, as->, some->, and some->> from 1.5 master. This lets ClojureScript users use these macros without requiring Clojure 1.5.

I suppose this maybe should wait until 1.5.0 is out, in case another renaming occurs.

Another way to do this would be to have import-macros ignore missing macros and add these there. Then the macros would only be available for users requiring Clojure 1.5 (which.. makes sense), and we wouldn't have to copy them.

[CLJS-437] Missing "Too few arguments to if" check

Fri, 7 Dec 2012 00:03:55 -0600

(if) and (if 1) both return nil. JVM clojure throws "Too few arguments to if".

[CLJS-436] defn missing arg vector gives error about max

Sat, 8 Dec 2012 18:13:17 -0600

defn missing arg vector gives error about max

[CLJS-435] Stack overflow error when adding large numerical keys to maps

Sat, 22 Dec 2012 14:01:36 -0600

The following code causes a stack overflow in Google Chrome browser and repljs. Transcript follows.

~/tools/clojurescript$  script/repljs
"Type: " :cljs/quit " to quit"
ClojureScript:cljs.user> (assoc {}
  154618822656 1
  261993005056 1)
"Error evaluating:" (assoc {} 154618822656 1 261993005056 1) :as "cljs.core.assoc.call(null,cljs.core.ObjMap.EMPTY,154618822656,1,261993005056,1);\n"
java.lang.StackOverflowError
        org.mozilla.javascript.NativeCall.<init>(NativeCall.java:65)
        org.mozilla.javascript.ScriptRuntime.createFunctionActivation(ScriptRuntime.java:3273)
        org.mozilla.javascript.gen.cljs_core_cljs_834._c__hash_1(cljs/core.cljs)
        org.mozilla.javascript.gen.cljs_core_cljs_834.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)
        org.mozilla.javascript.optimizer.OptRuntime.call2(OptRuntime.java:76)
        org.mozilla.javascript.gen.cljs_core_cljs_909._c_anonymous_3(cljs/core.cljs:905)
        org.mozilla.javascript.gen.cljs_core_cljs_909.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)
        org.mozilla.javascript.optimizer.OptRuntime.callN(OptRuntime.java:86)
        org.mozilla.javascript.gen.cljs_core_cljs_909._c_anonymous_5(cljs/core.cljs:913)
        org.mozilla.javascript.gen.cljs_core_cljs_909.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)
        org.mozilla.javascript.optimizer.OptRuntime.callN(OptRuntime.java:86)
        org.mozilla.javascript.gen.cljs_core_cljs_909._c_anonymous_2(cljs/core.cljs:893)
        org.mozilla.javascript.gen.cljs_core_cljs_909.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)
        org.mozilla.javascript.optimizer.OptRuntime.call2(OptRuntime.java:76)
        org.mozilla.javascript.gen.cljs_core_cljs_909._c_anonymous_5(cljs/core.cljs:911)
        org.mozilla.javascript.gen.cljs_core_cljs_909.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)
        org.mozilla.javascript.optimizer.OptRuntime.call2(OptRuntime.java:76)
        org.mozilla.javascript.gen.cljs_core_cljs_1175._c_anonymous_2(cljs/core.cljs:4481)
        org.mozilla.javascript.gen.cljs_core_cljs_1175.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)
        org.mozilla.javascript.optimizer.OptRuntime.callN(OptRuntime.java:86)
        org.mozilla.javascript.gen.cljs_core_cljs_1175._c_anonymous_4(cljs/core.cljs:4501)
        org.mozilla.javascript.gen.cljs_core_cljs_1175.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)
        org.mozilla.javascript.optimizer.OptRuntime.callN(OptRuntime.java:86)
        org.mozilla.javascript.gen.cljs_core_cljs_1169._c_anonymous_12(cljs/core.cljs:4388)
        org.mozilla.javascript.gen.cljs_core_cljs_1169.call(cljs/core.cljs)
        org.mozilla.javascript.optimizer.OptRuntime.callN(OptRuntime.java:86)
        org.mozilla.javascript.gen.cljs_core_cljs_1175._c_anonymous_2(cljs/core.cljs:4486)
        org.mozilla.javascript.gen.cljs_core_cljs_1175.call(cljs/core.cljs)
        org.mozilla.javascript.ScriptRuntime.applyOrCall(ScriptRuntime.java:2521)
        org.mozilla.javascript.BaseFunction.execIdCall(BaseFunction.java:300)
        org.mozilla.javascript.IdFunctionObject.call(IdFunctionObject.java:129)

[CLJS-434] ClojureScript compiler prepends "self__" to defmulti forms when metadata in form of ^:field.

Sun, 20 Jan 2013 00:54:25 -0600

Using the def form, with the specific metadata ^:field causes the cljs compiler
to prepend "self__" to the output js form.

The browser (latest chrome/firefox) does not recognize "self__".

Test Case: Tested against master: 5ac1503
-------------

(ns test-def)

(def ^:foo e identity)
e
; test_def.e = cljs.core.identity;
; test_def.e;

(def ^:field f identity)
f
; test_def.f = cljs.core.identity;
; self__.test_def.f;
; Uncaught ReferenceError: self__ is not defined

https://gist.github.com/4185793

[CLJS-433] Throw error when user tries to use wrong syntax for multiple arity functions in extend-type

Thu, 29 Nov 2012 16:20:05 -0600

Right now it allows to mix declarations, sometimes allowing an illegal syntax (-nth shouldn't be allowed in the following example)

example from jayq:

(extend-type js/jQuery

  IIndexed
  (-nth [this n] ...)
  (-nth [this n not-found] ...)

  ILookup
  (-lookup
    ([this k] ...)
    ([this k not-found] ...))

It already throws an error with some protocols such as IFn, but not for all of them.

[CLJS-432] Include line and file information in error messages

Fri, 30 Nov 2012 11:25:39 -0600

Just as the ana/warning function did, now errors and assertions include line and file source information. I needed this sorely.

[CLJS-431] namespace and name fail on '/

Fri, 30 Nov 2012 11:56:54 -0600

Both the 'namespace and the 'name functions use .lastIndexOf to search for "/". This fails on the division symbol if you don't provide a starting index to search from.

[CLJS-430] cljsc hangs for ~ 1 minute after code is generated

Sun, 2 Dec 2012 11:25:12 -0600

Running the Clojurescript compiler via command line hangs for ~1 minute after the compile is done. (By done I mean that complete code has been sent to stdout.)

I've observed this for a number of different options so I don't think it's related to options: optimization simple/advanced, pretty-print on/off, output-as used/not used.

I've tried using bin/cljsc and doing the command manually, a la:

$ cd bin
$ time java -cp "./../lib/*:./../src/clj:./../src/cljs:./../test/cljs" clojure.main "cljsc.clj" hello-world.cljs '{:optimizations :simple}'

I've only tested against one version of Clojurescript: today's master branch (0bfa1eac3599b55f3).

[CLJS-429] Data Conveying Exception: ex-data and ex-info

Thu, 6 Dec 2012 10:18:43 -0600

equivalent of http://dev.clojure.org/jira/browse/CLJ-733

as per https://groups.google.com/d/topic/clojure/vlTR_161WNc/discussion

[CLJS-428] Using */ inside of a docstring causes compiler to produce invalid JavaScript

Sat, 22 Dec 2012 15:30:04 -0600

Due to how function docstrings are output by the ClojureScript compiler, the use of

*/

within a docstring causes the compiler to produce invalid JavaScript, breaking compilation, since '*/' will close the docstring's JavaScript comment block and the remaining docstring text will be uncommented as a result.

[CLJS-427] Unqualified use of excluded/re-assigned set! symbol causes compilation error

Wed, 20 Feb 2013 08:40:52 -0600

Compilation (with :optimizations :whitespace) fails when using an unqualified, re-assigned set! symbol, producing the following exception:

java.lang.AssertionError: Assert failed: set! target must be a field or a symbol naming a var targetexpr
analyzer.clj:578 cljs.analyzer/eval337[fn]
...

(This only occurs when using set! without qualification.)

[CLJS-426] subvec function not behaving consitently with invalid subranges

Fri, 23 Nov 2012 15:25:10 -0600

When using the subvec function with a as a parameter vector and a range that is not in the original vector, the function returns a value:

(subvec [1 2 3] 0 4) => [1 2 3 nil]

However, when using with seqs, it works as it supposed to:

(subvec (range 3) 0 4) => ERROR: Index out of bounds

This is because the validation of ranges is not happening at build time of the subvec type, this bug contains a patch that adds a new private `build-subvec` function into cljs.core.

[CLJS-425] JavaScriptCore advanced compilation tests fail with StackOverflow

Sun, 20 Jan 2013 00:47:55 -0600

Regression - we need to git bisect to determine the commit.

[CLJS-424] Internal representation of keywords can not be differentiated by printable characters

Sat, 22 Dec 2012 15:45:34 -0600

Currently, Symbols are represented by (str \uFDD1 \' name) and keywords are represented by (str \uFDD0 \' name)

The \uFDDX character is not printable, so it appears as a little box when printed in a javascript repl such as the browser's console. The following character is always a \' regardless of whether the object is a symbol or a keyword. This has bitten me during debugging on several occasions. The attached patch changes keywords to be represented internally by (str \uFFD1 \: name)

[CLJS-423] ClojureScript REPL should take analyze-path as an option

Wed, 21 Nov 2012 09:07:39 -0600

This way the REPL can be started with warnings enabled. This is for REPLs where evaluation environment is persistent and remote (Browser, Node.js, etc)

[CLJS-422] circular dependencies triggers infinite loop

Wed, 21 Nov 2012 09:05:43 -0600

I believe this is because analysis follows dependencies naively.

[CLJS-421] add clj->js

Tue, 20 Nov 2012 08:26:05 -0600

For complex keys in maps pr-str should be sufficient and sets could just become JS arrays.

[CLJS-420] Unexpected behavior with dispatch on Keyword via protocols

Sun, 18 Nov 2012 15:27:05 -0600

At the moment if you create a protocol and expect it to be able to dispatch on keywords you need to do it in js/String, trying to extend on cljs.core.Keyword doesn't work as keywords are just Strings.

See https://gist.github.com/4104635

[CLJS-419] Exclude cljs source file from compilation

Tue, 18 Dec 2012 15:09:20 -0600

Scenario:

you have a :dev build and a :prod build
In the :dev build you want to have a brepl connected with the browser and you coded that connection in a isolated cljs source file.
In the :prod build you do not want that connection active, meaning you don't want source cljs file enabling the connection to be included in the compilation.

Given this scenario, you need to duplicate all the cljs source files but the one that enable the connection. This mean you have to manually maintain two code bases.

It could be useful to have a way to :exclude some files from :source-path.

[CLJS-418] Unspecified dependency on google-closure-library-third-party

Sat, 16 Feb 2013 14:59:54 -0600

Temporary fix to this issue: Add the G.Closure Library third-party extensions as a project dependency.

;; In :dependencies vector of Leiningen's project.clj
[org.clojure/google-closure-library-third-party "0.0-2029"]

We currently distribute the Google Closure Library in two separate JARs: the main library and the third-party extensions. We do this because the third-party extensions are covered by different licenses.

But, as it turns out, various classes in the main library have explicit dependencies on things in the third-party extensions. See See also this G.Closure mailing list discussion.

As a result, the ClojureScript browser-connected REPL has a transitive dependency on the Google Closure Library third-party extensions. This manifests as an error in script/cljsc and a NullPointerException in lein-cljsbuild.

See the initial Clojure-dev mailing list discussion and discussion of this ticket.

[CLJS-417] cljs.core/mod incorrect for negative numbers

Wed, 21 Nov 2012 09:11:54 -0600

JavaScript's % (modulo) operator gives incorrect answers for negative numbers, e.g.

-2 % 5 => -2

which carries over to cljs.core/mod

This blog: http://javascript.about.com/od/problemsolving/a/modulobug.htm

suggests defining modulo as:

Number.prototype.mod = function(n) {
  return ((this%n)+n)%n;
}

ClojureScript's mod should use this workaround

[CLJS-416] emit-block doesn't use context argument

Fri, 21 Dec 2012 17:30:54 -0600

emit-block currently has arguments [context statements ret] but the context argument is never used and all call sites always draw statements and ret from the same block AST node. The attach patch simplifies emit-block and all call sites to use arguments [{:keys [statement ret]}]

[CLJS-415] Speed up cljsc by exiting when work is done.

Sun, 2 Dec 2012 11:24:54 -0600

When following cljsc output with

tail -f test.js

you can see that even after the ouput is printed, the compiler waits a long time before exiting.
Attached patch flushes out, shuts down agents and exits at the end of the compilation thread. This reduces the apparent compilation time of test/ from 1m 13s to 13s on my machine.

[CLJS-414] Implement specify, allowing instances to implement protocols

Fri, 3 May 2013 19:30:54 -0500

Javascript objects are fully dynamic. Currently, ClojureScript has no mechanism to exploit that for protocol implementation.

~~CLJS-398~~ was a first attempt to implement an operation to extend single instances, but it fell short because it offered no control over which closures to attach onto the object (i.e. allocates every time). Also, specify is a much better name than extend-instance.

extend-type can be implemented in terms of specify (by specifying the .prototype), but extend-type has grown from its humble beginnings
https://github.com/clojure/clojurescript/blob/b75730da8abc3abc6134d8dd9ec426ab792d3662/src/clj/cljs/core.clj#L42
to an monster of complexity
https://github.com/clojure/clojurescript/blob/72e55315c6973caa74af39b66052424f73872033/src/clj/cljs/core.clj#L438
Currently it does

print warnings
optimize IFn impls
special case the Object "protocol"
special case js builtins

and all that in a single macro body. So this is also a good opportunity to do some refactoring.

specify should have an interface similar to extend-type. Additionally a lower level operation is needed to attach existing lambdas as protocol methods. It's called specify* in my current implementation. It takes a lambda for every specified protocol-method-arity, with a syntax loosely based on clojure.core/extend.

[CLJS-413] Using 'null' as a var name leads to illegal code

Fri, 21 Dec 2012 17:58:32 -0600

(ns pkg)

(def null "abc")

compiles to the following javascript

pkg.null = "abc";

which is not legal. Other reserved javascript keywords may have the same issue.

[CLJS-412] Undeclared warning when defining protocols

Fri, 21 Dec 2012 18:02:34 -0600

Evaluate the following in a ./script/repl session

(require '[cljs.compiler :as comp])
(require '[cljs.analyzer :as ana])

;; This trickery seems to be the minimum logic to prepare a top level namespace
(def repl-env
  (binding [ana/*cljs-ns* 'cljs.user]
    (-> (ana/empty-env)
        (ana/analyze '(ns some-ns))
        :env
        (assoc :ns (ana/get-namespace ana/*cljs-ns*)))))

(defn analyze [form]
  (binding [ana/*cljs-warn-on-undeclared* true]
    (ana/analyze repl-env form)))

(-> '(defprotocol P
       (f [_ x]))
  analyze
  keys) ; keys is just so the output isn't huge

The first time you evaluate that last form, you get an error like this one:

WARNING: Use of undeclared Var some-ns/f at line 45

You'll get similar errors each time you rename f and re-evaluate the form.

[CLJS-411] broken let cases

Fri, 2 Nov 2012 09:21:42 -0500

(assert (= "original" (let [x "original"
                            oce (fn [] x)
                            x "overwritten"]
                        (oce))))


(letfn [(x [] "original")
        (y [] (x))]
  (let [x (fn [] "overwritten")]
    (assert (= "original" (y)))))

[CLJS-410] support ^:expose annotation

Sun, 28 Oct 2012 14:51:10 -0500

(def ^:export m 1)
(defn foo [g]
  (g m))

Because of constant propagation GClosure may replace m in foo with 1. It may be better to for :export to implicitly :expose but we need to check the output.

http://developers.google.com/closure/compiler/docs/js-for-compiler

[CLJS-409] Small code cleanup for emitting goog.provide statements

Sat, 27 Oct 2012 16:52:59 -0500

Just abstracts out a duplicated piece of code.

[CLJS-408] Include :form on fn :methods in AST

Sat, 27 Oct 2012 16:52:42 -0500

All core CLJS AST nodes include a :form key. Several quasi-nodes similarly include their originating code forms. Although :fn nodes include their :form, it varies between single and multiple arity functions. I've found it easier to assume multiple arities and always analyze :methods directly. Unfortunately, the methods lack :form keys. This simple patch exposes the form of each method, simplifying function transformations.

[CLJS-407] cljs.import-test not run in test suite / ordering problem in the compiler

Fri, 21 Dec 2012 18:07:47 -0600

The test code from ~~CLJS-312~~ is not hooked up to the test suite, which is trivially fixed.

Hooking up the test, however reveals a deeper problem (besides that it has a failing assumption):

Presumably due to the goog.provides later in the files, the compiler orders the output wrong, which results in not provided errors.
Most interestingly, this problem goes away, when compiling from a prepopulated out directory, presumably because then the closure compiler handles the ordering?

[CLJS-406] reduce-kv doesn't work for all data structures

Wed, 21 Nov 2012 10:37:41 -0600

Right now reduce-kv is not implemented for ObjMap and broken for ArrayMap.

[CLJS-405] reify regression

Tue, 23 Oct 2012 18:28:20 -0500

(defprotocol IFoo (-foo [this x]))

(defn bar [f]
  (reify
    IFoo
    (-foo [_ x]
      (f x))))

((bar inc) 1) ;; throws

This fails because f in the -foo implementation while correctly identified as a field gets renamed via shadow analysis. Looks like it may have been caused by ~~CLJS-369~~.

[CLJS-404] Automate Browser REPL testing

Tue, 23 Oct 2012 16:01:48 -0500

It's worth investigating Selenium, PhantomJS, etc. as solutions to sanity check the Browser REPL when we run the other tests.

[CLJS-403] Printed JS code on REPL stack trace inconsistent with what got evaluated

Tue, 23 Oct 2012 18:50:51 -0500

This issue arose from http://dev.clojure.org/jira/browse/CLJS-397

The REPL uses a statement context to compile the code printed out as part of a stack trace. The code that runs, however, actually gets compiled in an :expr context, in a wrapper form.

Several ops (fn, constant, var) don't get emitted in a statement context. Thus a form a form like

(if (> 0.5 (Math/random))
(throw "")
:value)

gets compiled to

if (Math.random() > 0.5) { throw ""; }else{
}

according to the stack trace, while still returning :value half of the time.

[CLJS-402] Add a facility to obtain the version information of the clojurescript build that is in use

Tue, 26 Feb 2013 07:51:04 -0600

Currently there is no function or var defined in the clojurescript library that can be used to easily obtain the version information of the build that is in use.

Without that version information, debugging and reporting of errors is more cumbersome than needed, wastes time, causes confusion discussing issues...

A simple function and/or var like the ones used for clojure would be very helpful:

user=> (clojure-version)
"1.4.0"
user=> clojure-version
{:major 1, :minor 4, :incremental 0, :qualifier nil}

[CLJS-401] top level let emits vars without namespace

Fri, 2 Nov 2012 13:51:52 -0500

top level let emits vars without namespace

[CLJS-400] Stop using goog.string.quote to escape strings for printing

Mon, 22 Oct 2012 18:06:32 -0500

The contract of goog.string.quote is to produce a "valid JavaScript string", which can end up being quite different from what is expected by e.g. the Clojure reader and other edn-compatible readers. This has been discussed in a variety of threads/issues:

The most significant issue is that characters > 127 and < 256 are outputted with an \x.. escape sequence, which no other reader supports. Further, other Unicode characters are always escaped using the \u.... notation; this is not a functional difference, but can be a stumbling block, e.g. when viewing data that had been pr-str'd that contains high codepoint characters.

The most straightforward fix is to take control of printed string escaping to ensure the results conform first to the expectations of existing readers (primarily Clojure's and ClojureScript's), and to the formal [edn specification](https://github.com/edn-format/edn/) as that matures.

This ticket supersedes http://dev.clojure.org/jira/browse/CLJ-1025.

[CLJS-399] Lazy initialize global-hierarchy

Tue, 23 Oct 2012 18:54:37 -0500

Depends on extend-instance http://dev.clojure.org/jira/browse/CLJS-398

First patch backs atoms by a protocol IPlace and implements reset! and swap! and compare-and-set! only with protocols

Second patch uses extend-instance to implement global-hierarchy a custom lazy atom

In effect, multimethods and hierarchies can be omitted by gclosure, taking 1K off of hello world

https://groups.google.com/d/topic/clojure/LNfJRw07u8I/discussion

[CLJS-398] new macro cljs.core/extend-instance

Fri, 19 Oct 2012 19:51:02 -0500

Patch introduces an extend-instance macro, similar to extend-type.
It doesn't extend the .prototype property, but assigns the prototype impl members to the instance itself.

This is useful to let existing instances, e.g. parsed JSON directly implement a protocol.

[CLJS-397] Omit var reads in statement context

Tue, 23 Oct 2012 18:49:53 -0500

Attached patch updates cljs emitter to not emit var references in statement context.
That causes toplevel deftypes to not return their generated type, which lets gclosure strip them if unused

cljs helloworld shrinks from ~90K to ~69K

https://groups.google.com/d/topic/clojure/LNfJRw07u8I/discussion

[CLJS-396] "Simplify" lower-case and upper-case functions in cljs.string

Sat, 22 Dec 2012 15:26:26 -0600

"Simplify" lower-case and upper-case functions in cljs.string

[CLJS-395] nodejs target no longer works

Tue, 23 Oct 2012 18:33:27 -0500

If you target nodejs by adding {:target :nodejs} to the options (and set main-cli-fn) , you get this error:

https://gist.github.com/3892983

This appears to have been introduced with this commit: https://github.com/clojure/clojurescript/commit/d6f7d0b193de22378e06298fa543ca57d570c001

It spits out that error and nothing else. Any versions before that works fine.

Related: ~~CLJS-355~~

[CLJS-394] PersistentTreeSet lookup bug

Mon, 15 Oct 2012 22:02:51 -0500

The lookup function in PersistentTreeSet behaves differently in clojurescript than in clojure when a custom comparison function is used. If two elements are evaluated as equal, one of then is in the set and we do a lookup on the other, clojure returns the element in the set, whereas clojurescript returns the lookup element.

(let [compare-quot-2 #(compare (quot %1 2) (quot %2 2))
s (sorted-set-by compare-quot-2 1)]
(get s 0))

Should return: 1
Returns: 0

[CLJS-393] sebseq and sorted-set-by

Thu, 18 Oct 2012 17:44:31 -0500

ClojureScript:cljs.user> (subseq (sorted-set-by <= 1 2 3 4 5) >= 2 <= 4)
"Error evaluating:" (subseq (sorted-set-by <= 1 2 3 4 5) >= 2 <= 4) :as "cljs.core.subseq.call(null,cljs.core.sorted_set_by.call(null,cljs.core.LTEQ,1,2,3,4,5),cljs.core.GTEQ,2,cljs.core.LTEQ,4);\n"
org.mozilla.javascript.JavaScriptException: Error: No protocol method IMapEntry.-key defined for type null: (cljs/core.cljs#211)
at cljs/core.cljs:211 (anonymous)
at cljs/core.cljs:203 (_key)
at cljs/core.cljs:5535 (key)
at cljs/core.cljs:2479 (anonymous)
at cljs/core.cljs:1791 (lazy_seq_value)
at cljs/core.cljs:1840 (anonymous)
at cljs/core.cljs:238 (_seq)
at cljs/core.cljs:343 (seq)
at cljs/core.cljs:817 (anonymous)
at cljs/core.cljs:854 (anonymous)
at cljs/core.cljs:857 (anonymous)
at cljs/core.cljs:868 (anonymous)
at cljs/core.cljs:5925 (anonymous)
at cljs/core.cljs:5937 (anonymous)
at <cljs repl>:1 (anonymous)
at <cljs repl>:1

[CLJS-392] Documentation says CLJS can open connections to the REPL server from a "file://" source, and you can't

Wed, 24 Oct 2012 14:48:48 -0500

At https://github.com/clojure/clojurescript/wiki/The-REPL-and-Evaluation-Environments there is the following paragraph:

"This is a problem for the browser-connected REPL because FireFox and Chrome both view opening a file from the file system and connecting to localhost:9000 as different domains.
(...)
Fortunately, Google has also run into this problem and has created something called a CrossPageChannel. Without going into the details, this allows an iframe served from one domain (the REPL) to communicate with the parent page which was served from another domain (the application server)."

From what I tested, you CANT connect to the REPL server at "http://localhost:9000/repl" if you initially loaded the page using the "file://" protocol. But you can if you loaded it from the same hostname on another port using "http://". The documentation is wrong, and also it needs to be clarified on what you really can change from the initial domain, like the port, without broking the REPL connection (or link to a CrossPageChannel documentation page with the details on what same-origin policy checks it can overcome).

[CLJS-391] IndexedSeq, RSeq, ChunkedCons, and PersistentTreeMapSeq do not satisfy IEmptyableCollection

Tue, 9 Oct 2012 17:49:17 -0500

Attached patch (add-some-missing-IEmptyableCollection-impls.patch, 8 Oct 2012) fixes this. I checked that each of the corresponding types in Clojure is emptyable.

[CLJS-390] analyzer tries to descend on macro files

Mon, 15 Oct 2012 23:05:25 -0500

Macro deps are added to the set of deps to be analyzed. Normally this would be harmless, since if a corresponding cljs file isn't found, analyze-deps just skips it. But consider the following case:

(ns foo.bar
  (:require-macros [foo.bar :as b]))

In this case the analyzer overflows the stack, recursively trying to analyze foo/bar.cljs over and over. The attached patch (exclude-macro-files-from-analysis.patch, 8 Oct 2012) seems to fix this. I am not sure whether it causes any new problems.

[CLJS-389] Compiler emits throw string

Mon, 15 Oct 2012 21:59:57 -0500

http://github.com/clojure/clojurescript/blob/master/src/clj/cljs/compiler.clj#L468

[CLJS-388] expose :output-wrapper compile option

Mon, 15 Oct 2012 22:26:57 -0500

expose :output-wrapper compile option

[CLJS-387] Add docstring from def and ns definitions to @namespaces metadata map, and make reflect functions make use of that

Wed, 17 Oct 2012 10:57:56 -0500

The docstrings were parsed from the definitions-forms for def and ns, but not added to the @namespaces metadata map.
There is no :doc entry used in the ns' metadata in the @namespaces.
No ns's :doc info is communicated to the browser in the reflect functions with reflect/doc.
Patch-file is attached with code-changes that add the :doc info for ns and def to the @namespaces, and enhances the reflect functions to communicate that info to the browser in the reflect/doc call.

[CLJS-386] Remove TODO comments in clojure.browser.dom

Sat, 22 Dec 2012 15:25:36 -0600

Remove line https://github.com/clojure/clojurescript/blob/master/src/cljs/clojure/browser/dom.cljs#L151
and https://github.com/clojure/clojurescript/blob/master/src/cljs/clojure/browser/dom.cljs#L152

Because we can just use Google Closure class library directly:
(ns boom.core
(:require [clojure.browser.dom :as dom]
[goog.dom.classes :as cl]
[goog.dom :as gdom]))

(def el (gdom/getElement "some-element"))

;; Add class
(cl/add el "boom")
;; Remove class
(cl/remove el "boom")
;; Toggle class
(cl/toggle el "boom")
...

[CLJS-385] ClojureScript's hashbang for Node.js output is not universal

Tue, 9 Oct 2012 17:48:52 -0500

Currently on `src/clj/cljs/closure.clj:859` - the shebang/hashbang for node-targeted compilation is `/usr/bin/nodejs`.

This limits the potential reach. Instead we could rely upon `env` which is more universal.
Additionally, the node binary is most commonly called `node`

A patch is attached.

[CLJS-384] Rhino and browser REPL namespaces both extend IJavaScriptEnv to IPersistentMap

Fri, 28 Sep 2012 15:55:56 -0500

This means that:

1. Whichever REPL environment namespace is loaded last determines which IJavaScriptEnv impl is used for an "active" REPL environment map.
2. One cannot use both Rhino and browser REPLs at the same time.

[CLJS-383] Empty variadic argument initialised with (nil) when using arity overloading

Wed, 17 Oct 2012 10:48:12 -0500

Empty variadic argument (& rest) is incorrectly initialised with (nil), when variadic arguments are used together with overloading.
See following example:

(defn foo
[& TEST]
TEST)

(foo)
=> nil ;; correct

(foo 1 2)
=> (1 2) ;; correct

(defn bar
([]
:empty)
([A & B]
B))

(bar)
=> :empty ;; correct

(bar 1 2)
=> (2) ;; correct

(bar 1)
=> (nil) ;; error - should be nil

[CLJS-382] Compiling with dependencies breaks under Clojure 1.5.0 alphas

Wed, 26 Sep 2012 14:32:30 -0500

This Clojure commit changed contains? to throw an exception when called with a non-associative collection. Unfortunately, cljs.closure/js-dependencies does exactly that, so many compilation scenarios will cause this error:

IllegalArgumentException contains? not supported on type: clojure.lang.LazySeq

This should also make compilation more efficient, insofar as the contains? call has always been failing (checking for a string or symbol key in a sequence).

[CLJS-381] Implement cljs$lang$applyTo on String.prototype instead of apply

Wed, 21 Nov 2012 10:19:57 -0600

Implement cljs$lang$applyTo on String.prototype instead of apply

[CLJS-380] fix "contains? not supported on LazySeq" bug in cljs.closure/js-dependencies

Fri, 28 Sep 2012 17:49:14 -0500

js-dependencies apparently assumes that its requires arg is a set (despite the docstring). This breaks the browser repl for me. Stack trace: https://gist.github.com/96a7e93ac48d8430700e

Attached patch cljs-380.patch (19 Sep 2012) fixes it.

[CLJS-379] optimize tail call in linear-traversal-nth

Fri, 28 Sep 2012 17:49:54 -0500

linear-traversal-nth is tail-recursive but doesn't call recur, so e.g. `(nth (iterate inc 0) 1e5)` can overflow the stack.

Attached patch cljs-379.patch (17 Sep 2012) fixes this.

[CLJS-378] port clojure.data

Thu, 20 Sep 2012 11:24:40 -0500

clojure.data ports somewhat nicely to ClojureScript. The only wrinkle is that clojure.data extends its protocols to the java.util.Map/Set/List interfaces, which doesn't work in ClojureScript. The naive solution is to extend the protocols to every relevant type. I've done this in the attached patch 0001-~~CLJS-378~~-port-clojure.data.patch (16 Sep 2012).

[CLJS-377] ns' :refer and :only options accept only vectors

Thu, 13 Sep 2012 12:14:08 -0500

ClojureScript requires vectors for the :refer and :only options of :use and :require clauses in its ns forms, whereas Clojure allows vectors or lists.

That is, this works:

(ns foo
 (:require [com.bar :as bar :refer [baz]]))

...but this doesn't:

(ns foo
 (:require [com.bar :as bar :refer (baz)]))

Presuming ClojureScript should maintain compatibility with Clojure where possible, this should not be the case:

The Clojure documentation for both require and refer specify that lists of symbols should be used for these options.
The canonical example of libspecs uses a list literal for its :only option.
Lots of Clojure code (especially purely algorithmic stuff) that otherwise works just fine in ClojureScript won't load because of the latter's vector requirement.

This topic was raised and (briefly discussed) on clojure-dev.

[CLJS-376] `case` doesn't match quoted symbols

Fri, 7 Sep 2012 16:49:37 -0500

It works fine in the Clojure 1.4.0 REPL:

user=> (let [a 'a] (case a nil :nil '& :amp :none))
:none
user=> (let [a '&] (case a nil :nil '& :amp :none))
:amp
user=> (let [a 'b] (case a nil :nil 'b :b :none))
:b

But in the CLJS Rhino REPL this is what I see:

ClojureScript:cljs.user> (let [a 'a] (case a nil :nil '& :amp :none))
:none
ClojureScript:cljs.user> (let [a '&] (case a nil :nil '& :amp :none))
:none
ClojureScript:cljs.user> (let [a 'b] (case a nil :nil 'b :b :none))
:none

[CLJS-375] loop doesn't seem to preserve tag information as evidenced by extra cljs.core.truth_ calls

Thu, 6 Sep 2012 20:33:14 -0500

loop doesn't seem to preserve tag information as evidenced by extra cljs.core.truth_ calls

[CLJS-374] satisfies? produces strange code when the protocol is not in the fast-path list

Thu, 6 Sep 2012 20:27:44 -0500

satisfies? produces strange code when the protocol is not in the fast-path list

[CLJS-373] Automatically add `var CLOSURE_NO_DEPS = true;` to output if only whitspace optimizations are being applied

Thu, 6 Sep 2012 18:49:53 -0500

Without this, using the output of :whitespace compilation will produce 404's as documented e.g. here.

[CLJS-372] align standard out printing behavior with Clojure

Sun, 9 Sep 2012 17:51:48 -0500

The behavior and print and println do not mirror Clojure's. This makes figuring out how to print to standard out consistently a bit of guessing game. The fixes in ~~CLJS-340~~ have changed the output of the benchmarks which made me notice that the issue is pervasive.

To see the basic issue run ./script/benchmark before and after the ~~CLJS-340~~ fix.

[CLJS-371] deprecation warning for IPrintable

Fri, 12 Oct 2012 11:58:37 -0500

Now that ~~CLJS-340~~ has landed, we need a deprecation warning for IPrintable / -pr-seq

[CLJS-370] Incorrect behavior of integer? for integral floating point expressions

Wed, 5 Sep 2012 11:40:48 -0500

This includes infinity, exponential expressions, etc.

See: http://stackoverflow.com/questions/3885817/how-to-check-if-a-number-is-float-or-integer

[CLJS-369] gensyms break re-analyze; prevents variable shadowing analysis

Wed, 17 Oct 2012 10:53:50 -0500

From my email discussion with dnolon before making this patch:

The current analyzer does some trickery to prepare for emitting to JavaScript. Among this trickery is gensyms for locals (including "this"), the new $ prefix on some namespaces, uniqify on parameters, and more. This must be mildly annoying for people writing alternate compiler backends, but for the most part non-blocking because fewer symbol collisions should never be an additional problem for a target language with different symbol resolution rules.

[snip lots more text]

Consider what an ANF transform would look like for the :let form:

(defmethod anf :let
  [{:keys [env bindings statements ret form] :as ast}]
  (let [bindings (mapcat (fn [{:keys [sym init] :as binding}]
                           [name (anf init)])
                         bindings)
        body-env (-> bindings last :env)]
    (ana/analyze env `(~(first form) [~@(map :form bindings)]
                          ~@(anf-block (assoc ast :env body-env))))))

Simple enough, right? This walks each binding, ANF transforms the init expression, gets the environment in which to analyze the body, and then analyzes a new let (or loop) statement with the modified bindings.

Unfortunately, this doesn't work. When the ana/analyze call happens, body-env contains gensymed locals. The result is that body-env is invalidated by the outer analyze call, which is re-generating the symbols for the local variables. If you take the gensyms out of analyze-let, then analyze becomes pure (modulo def forms) and this code magically becomes correct. I've run into this same problem anywhere gensyms are used in analyze.

Commit message on the patch:

AST Changes
    
    * Anywhere a binding was introduced for a local used to be a symbol,
      now it is a map with a :name key and potentially a :shadow key.
    
    * Bindings vectors are no longer alternating symbols, then init maps.
      Instead, the are a vector of maps of the shape described for locals
      plus an :init key.
    
    * The :gthis key for functions has been replaced with :type, which
      is the symbol describing the type name of the enclosing deftype form.
    
    * recur frames now expose :params as binding maps, instead of :names
    
    Benefits:
    
    * Shadowed variables are now visible to downstream AST transforms.
    
    * :tag, :mutable, and other metadata are now uniform across ops
    
    * Eliminates usages of gensym inside the analyzer, which was a source
      of state that made the analyzer impossible to use for some
      transformations of let, letfn, etc which require re-analyzing forms.
    
    * Removes JavaScript shadowing semantics from the analyze phase.

[CLJS-368] faster empty? for nil inputs

Wed, 17 Oct 2012 10:58:18 -0500

empty? always calls seq, which is unnecessary if input is nil. By explicitly checking for nil before calling seq, empty? perform up to 4 times faster (measured on v8) for nil inputs. Patch included.

[CLJS-367] doseq & for macros should support chunked seqs

Fri, 26 Apr 2013 16:55:00 -0500

doseq & for macros should support chunked seqs

[CLJS-366] doseq's :when clause always fails: "recur not supported here".

Thu, 30 Aug 2012 20:06:03 -0500

(for [i '(0 1 2 3) :when (pos? i)] i) works correctly, while (doseq [i '(0 1 2 3) :when (pos? i)] i) will throw a java.lang.AssertionError.

[CLJS-365] apply needs to put all args after the 20th into an array seq

Wed, 29 Aug 2012 20:36:00 -0500

This ticket is related to ~~CLJS-359~~

[CLJS-364] compiler needs to put all args of an invocation after 20 into an array-seq

Wed, 29 Aug 2012 20:35:42 -0500

This ticket is related to ~~CLJS-359~~

[CLJS-363] `format` %s behavior is incorrect for keyword, symbol etc.

Wed, 29 Aug 2012 19:54:29 -0500

On the Clojure REPL, `format` works fine:

user=> (format "foo%s" :s) 
"foo:s" 
user=> (format "foo%s" 's) 
"foos"

However, on the CLJS REPL (Rhino), the output is different:

ClojureScript:cljs.user> (format "foo%s" :s) 
"foo 's" 
ClojureScript:cljs.user> (format "foo%s" 's) 
"foo 's"

Reference: http://groups.google.com/group/clojure/browse_thread/thread/b253d810536a4046

[CLJS-362] Varargs protococol impls can be defined but not called

Wed, 20 Feb 2013 08:41:48 -0600

Pretty much the same issue I described here http://dev.clojure.org/jira/browse/CLJ-1024 but for ClojureScript rather than for Clojure. After the following declaration:

(extend-protocol IFn js/Array (-invoke ([& args] args)))

Calling ((array) 1 2 3) will return 1 rather than (1 2 3).

[CLJS-361] Invoking anonymous functions with wrong arity does not produce a warning

Thu, 30 Aug 2012 18:08:57 -0500

When an anonymous function is invoked with incorrect arity, no warning message is displayed:

ClojureScript:cljs.user> (let [f #(do 1)] (f 2)) 
1 
ClojureScript:cljs.user> (let [f (fn [] (do 1))] (f 2)) 
1 
ClojureScript:cljs.user> (let [f (fn [_] (do 1))] (f 2)) 
1 
ClojureScript:cljs.user> (let [f (fn [_ _] (do 1))] (f 2)) 
1 
ClojureScript:cljs.user> (let [f (fn [x y] (do 1))] (f 2)) 
1 
ClojureScript:cljs.user> (defn f [] 1) 
#< 
function f() { 
    return 1; 
} 

ClojureScript:cljs.user> (f 2) 
WARNING: Wrong number of args (1) passed to cljs.user/f at line 8 
1

[CLJS-360] Analyzer incorrectly merges metadata when redefining vars

Fri, 31 Aug 2012 11:29:48 -0500

I'm experimenting with using the analyzer for some more sophisticated macros, including a CPS transform and control constructs. During interactive development, I discovered that the analyzer is incorrectly merging metadata on vars when redefining them. This patch changes redef's to replace, rather than merge, existing var metadata.

The patch does not include a test, since the tests don't currently muck with the analyzer directly. Here's some code you can play with in your repl:

(require '[cljs.analyzer :as ana])
(require '[cljs.compiler :as comp])

(def env (ana/empty-env))

(defn show-foo [form]
  (ana/analyze env form)
  (-> @ana/namespaces (get 'cljs.user) :defs (get 'x) :foo))

(show-foo '(def ^{:foo 1} x 1))

(show-foo '(def ^{:foo 2} x 1))

(show-foo '(def x 1))  ; before patch, this returns 2. After patch, nil.

[CLJS-359] `with-meta` does not work on function objects

Wed, 21 Nov 2012 16:21:13 -0600

`with-meta` does not working on function objects in CLJS. Compilation fails with the following error:

Error: No protocol method IWithMeta.-with-meta defined for type function: function { return x; }

I tried it out on the REPL and found the following:

---------- BEGIN: repl-rhino ----------
ClojureScript:cljs.user> (with-meta #(do :foo) {:foo :bar})
"Error evaluating:" (with-meta (fn* [] (do :foo)) {:foo :bar}) :as "cljs.core.with_meta.call(null,(function (){\nreturn \"\\uFDD0'foo\";\n}),cljs.core.ObjMap.fromObject([\"\\uFDD0'foo\"],{\"\\uFDD0'foo\":\"\\uFDD0'bar\"}));\n"
org.mozilla.javascript.JavaScriptException: Error: No protocol method IWithMeta.-with-meta defined for type function:
function () { return "\ufdd0'foo"; }
(cljs/core.cljs#222)
at cljs/core.cljs:222 (anonymous)
at cljs/core.cljs:214 (_with_meta)
at cljs/core.cljs:806 (with_meta)
at <cljs repl>:2 (anonymous)
at <cljs repl>:2

nil
---------- END: repl-rhino ----------

Reference: https://groups.google.com/forum/?fromgroups=#!topic/clojure/pRO-5IlilNM

[CLJS-358] Cannot restart Rhino ClojureScript REPL

Sat, 26 Jan 2013 11:00:06 -0600

In at least some environments (some have not been able to replicate this, others have), the ClojureScript REPL cannot be restarted. Here's an example interaction, using the stock script/repl script and a clean clone of ClojureScript (v0.0-1465-gdf6f316):

la-mer:cljs chas$ script/repl
Clojure 1.4.0
user=> (require '[cljs.repl :as repl])
nil
user=> (require '[cljs.repl.rhino :as rhino])
nil
user=> (repl/repl (rhino/repl-env))
"Type: " :cljs/quit " to quit"
ClojureScript:cljs.user> (+ 1 2 3)
6
ClojureScript:cljs.user> :cljs/quit
nil
user=> (repl/repl (rhino/repl-env))
"Type: " :cljs/quit " to quit"
ClojureScript:cljs.user> (+ 1 2 3)
"Error evaluating:" (+ 1 2 3) :as "((1 + 2) + 3);\n"
org.mozilla.javascript.EcmaError: TypeError: Cannot read property "StringBuffer" from undefined (cljs/core.cljs#6154)
at cljs/core.cljs:6154 (pr_sb)
at cljs/core.cljs:6168 (pr_str_with_opts)
at cljs/core.cljs:6212 (anonymous)
at cljs/core.cljs:6219 (anonymous)
at <cljs repl>:7

nil
ClojureScript:cljs.user>

[CLJS-357] Large PersistentVector benchmarks

Wed, 29 Aug 2012 20:00:54 -0500

We need benchmarks for large data structures, e.g. large PVs with shifts greater than 5 (a shift of 20 would perhaps be problematic due to the necessary size of the vector, so probably 10 or 15).

My first cut at a patch (to be attached in a moment) provides benchmarks for building a large vector without using transients (to get an idea of conj perf), conjing onto a large vector in a situation where this involves a push-tail operation, associng in non-tail position in a large vector and popping a large vector where this involves a pop-tail op.

The push-tail / pop-tail benchmarks, as written here, are dependent on the exact position of the tail inside the vector; as an alternative, we could benchmark conjing / popping 32 times (max tail length is probably going to be pretty stable). Thoughts?

[CLJS-356] `read-string` exception message should be the same as in Clojure

Fri, 17 Aug 2012 00:40:51 -0500

When I run (read-string ""), I get the exception message "EOF while reading" on Clojure (clojure.core) but on ClojureScript (cljs.reader) the message is just "EOF".

ClojureScript's `read-string` should be fixed to match the error message "EOF while reading".

Reference: https://groups.google.com/forum/?fromgroups#!topic/clojure/k-ZX5MaXoiQ%5B1-25%5D

[CLJS-355] Targeting nodejs, compiling multiple files fail

Sat, 29 Sep 2012 12:40:51 -0500

I talked about this one with Brandon Bloom in #clojure and he figured out the issue. He asked me to open this issue, but I am utterly unclear on what the actual problem is, so I'm just going to provide the info he told me to provide along with what he said and hope for the best.

The problem began when I added a second file to a little project I was doing, targeting nodejs. I started getting this:

/Users/anthony/code/refh/refh.js:5478
var c = a.cljs$lang$maxFixedArity;
^
TypeError: Cannot read property 'cljs$lang$maxFixedArity' of null
at cljs.core.apply.b (/Users/anthony/code/refh/refh.js:5478:14)
at cljs.core.apply.a (/Users/anthony/code/refh/refh.js:5520:18)
at Object.<anonymous> (/Users/anthony/code/refh/refh.js:12328:17)
at Module._compile (module.js:449:26)
at Object.Module._extensions..js (module.js:467:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Module.runMain (module.js:492:10)
at process.startup.processNextTick.process._tickCallback (node.js:244:9)

Brandon had me open up the output file and look at the line.

cljs.core.apply.call(null, cljs.core.STAR_main_cli_fn_STAR, cljs.core.drop.call(null, 2, cljs.nodejs.process.argv));

The problem is that this code comes before the code that actually sets the main-cli-fn.

From IRC:

[17:28:59] <bbloom> oh DUH. i know the issue!
[17:29:31] <bbloom> your file is being compiled
[17:29:32] <bbloom> not run
[17:29:45] <bbloom> then that's going into a big bag of namespaces
[17:30:00] <bbloom> which are being compiled, not run
[17:30:32] <bbloom> so it's not compile order, it's execution order
[17:30:43] <bbloom> nodejscli is being executed before the code that sets the main fn

I have a small branch on Github that should provide a reproducible case. It uses lein-cljsbuild with simple optimizations. Give 'lein cljsbuild once' a shot. https://github.com/Raynes/refh/tree/cljs

[CLJS-354] node.js sys is now util

Sat, 11 Aug 2012 21:03:50 -0500

Whenever one compiles anything targeting node.js, running the result prints the following output:

The "sys" module is now called "util". It should have a similar interface.

Looks like this happened in recent versions of node.

[CLJS-353] Use different primitives for array access and property/object access

Wed, 29 Aug 2012 20:35:01 -0500

In javascript, array access (array[index]) and property access (object["property"]) have the same syntax, hence aget/aset are used for both in the core library.

But this isn't true for every target language. For example in Lua, there are no arrays, so if you want to have an array like container, array access will need to go through a function.

This patch proposes to add new builtins : oget and oset (for obj-get obj-set) and use them where appropriate. The generated code will be the same for javascript, but will enable alternate backend implementers to treat both differently

[CLJS-352] Protocols cannot be imported using :use :only

Tue, 4 Sep 2012 10:01:25 -0500

When protocol is imported using :use :only, it is not fully recognized in code. If we have protocol Map, defined in map.cljs, imported to google.cljs, name of generated method looks like this:

locations.google.Google.prototype.locations$google$Map$init$arity$4

When protocol is imported using :require :as, generated name is correct and looks like this:

locations.google.Google.prototype.locations$map$Map$init$arity$4

`satisfies?` also is saying that record is not implementing protocol, when :use :only is used. I hope what I wrote makes sense. If it does not, I'm happy to provide more details.

[CLJS-351] replace .-length usage with alength

Tue, 14 Aug 2012 05:34:02 -0500

replace .-length usage with alength

[CLJS-350] record printed form is inconsistent with Clojure

Wed, 8 Aug 2012 21:28:15 -0500

ClojureScript:cljs.user> (defrecord Bar [x])
cljs.user/Bar
ClojureScript:cljs.user> (Bar. 1)
#Bar{:x 1}

Clojure 1.4.0
user=> (defrecord Bar [x])
user.Bar
user=> (Bar. 1)
#user.Bar{:x 1}

This makes round-tripping records between Clojure and Clojurescript challenging.

[CLJS-349] cljs.compiler: No defmethod for emit-constant clojure.lang.LazySeq

Wed, 31 Oct 2012 22:10:24 -0500

The cljs compiler errors when trying to emit-constant for a clojure.lang.LazySeq.

Example : https://www.refheap.com/paste/3901

Here syms is defined as a LazySeq on line 3, then on line 7 it is quoted. The error is included in the refheap.

Emitting a cljs.core.list for this type seems to solve the issue.

[CLJS-348] Failure when using seq keys for PersistentHashMap

Wed, 1 Aug 2012 03:21:55 -0500

If you create a PersistentHashMap with a key that is a seq, lookup on that key fails:

 
ClojureScript:cljs.user> ((hash-map (seq [1 2]) :a) [1 2])
nil

[CLJS-347] extend-type js/String fails for empty string

Wed, 29 Aug 2012 20:43:18 -0500

When using extend-type on the Javascript String type, trying to call the protocol method with empty string fails with the following message: "No protocol method ProtocolName.method defined for type string: "

To repro, compile the include cljs file and run it by opening the esp.html file.

The output in the Javascript console will be:
ABC
Uncaught Error: No protocol method CaseProtocol.case-upper defined for type string:

The expected output is
ABC
<newline>

[CLJS-346] CLJS-319 broke behavior of println when given no arguments

Mon, 3 Sep 2012 14:48:58 -0500

It should print an empty string, not nil. See ~~CLJS-319~~.

[CLJS-345] clojure.reflect support for Rhino REPL

Wed, 25 Jul 2012 14:34:45 -0500

clojure.reflect should work for the Rhino REPL

[CLJS-344] clojure.reflect is asynchronous (should use CrossPageChannel)

Mon, 8 Oct 2012 17:24:49 -0500

This makes printing at the REPL a bit annoying. We should be using the CrossPageChannel and not a ajax request to the built in webserver.

[CLJS-343] make clojure.reflect fns conform to standard names

Sun, 29 Jul 2012 18:52:59 -0500

clojure.reflect/doc, clojure.reflect/meta etc

[CLJS-342] Send proper content types when serving JPGs, PNGs and stylesheets.

Wed, 29 Aug 2012 20:34:32 -0500

The send-static fn in the browser repl tries to detect the content
type of a file by it's pathname extension. This patch adds support for
JPGs, PNGs and stylesheets as well.

Without proper content type Chrome and Firefox are refusing to
apply stylesheets.

[CLJS-341] dissoc of optional keys on a Record removes all optional keys

Wed, 25 Jul 2012 09:28:58 -0500

dissoc does not work correctly when removing optional keys from a Record. dissocing an optional key will remove all optional keys.

The assertion below will fail.

(defrecord A [a b])
(def something (assoc (A. 1 2) :c 3 :d 4))
(assert (= (set (keys (dissoc something :c))) #{:a :b :d}))

When dissocing :c, :d is also removed.

[CLJS-340] improve pr-str performance

Fri, 7 Sep 2012 11:11:20 -0500

Currently pr-str performance is terrible. We should implement printing in the same style as core_print.clj Clojure JVM.

[CLJS-339] (inc nil) returns 1 instead of throwing an exception

Mon, 23 Jul 2012 13:21:27 -0500

(inc nil) => 1 in ClojureScript
(inc nil) => raise NullPointerException in Clojure

I think that Clojure's behavior (throwing) makes more sense in this context.

[CLJS-338] Incorrect implementation of IReduce by ArrayChunk

Tue, 14 Aug 2012 06:29:35 -0500

(reduce + (array-chunk (array 1 2 3 4) 1 3)) => 2 (instead of 5)
(reduce + 0 (array-chunk (array 1 2 3 4) 1 3)) => 3 (instead of 5)
(reduce + (array-chunk (array 1 2 3 4) 1 1)) => 2 (instead of 0)

In src/cljs/cljs/core.cljs, line #1817:
(deftype ArrayChunk [arr off end]
;; ...
IReduce
(-reduce [coll f]
(ci-reduce coll f (aget arr off) (inc off))) ;; should be (if (< off end) (ci-reduce coll f (aget arr off) 1) 0)
(-reduce [coll f start]
(ci-reduce coll f start off))) ;; should be (ci-reduce coll f start 0)

[CLJS-337] Shell scripts in cljs tree incompatible with baseline POSIX sh, cannot deal w/ filenames w/ whitespace

Mon, 16 Jul 2012 17:34:03 -0500

At present, the cljsc wrapper uses an unquoted $* to append all arguments to the end of the Java command running clojure.main, and fails to quote the CLJSC_CP variable dereference.

This means that both of these values are string-split and glob-expanded, rather than having their contents passed verbatim as individual argv array members. Similar issues occur in failing to properly quote the expansion of SPIDERMONKEY_HOME, JSC_HOME, V8_HOME, etc.

This will cause a failure if the CLOJURESCRIPT_HOME directory, or the name of the file or directory being compiled, contains whitespace. It also means that the command-line interface has to piece together multiple argv array elements to form the options map, rather than being able to parse it as a single entity, which is unfortunate in and of itself.

Also, the == operator to test is frequently used. This is a bash extension; baseline POSIX /bin/sh specifies only = as a test operator, and the presence of this extension should not be relied on.

Also, the [ "x$1" = "xfoo" ] test idiom is used in some cases. This is a holdout from ancient pre-POSIX Bourne shells which could not handle strings starting with - in this position, and is no longer considered good practice for generating readable shell code.

Also, <<EOF >file, while correct, tends to confuse syntax highlighting in common editors (including bash). The more common ordering >file <<EOF should be used instead.

Also, dots are not special in glob expressions (unlike regular expressions), and do not need to be quoted.

[CLJS-336] Hyphenated Protocols

Fri, 31 Aug 2012 09:20:37 -0500

(ns bug)

(defprotocol foo-bar-p
  (qux[this])
  (baaz [this a]))

(defrecord foo-bar []
  foo-bar-p
  (qux [this] "qux")
  (baaz [this a]
    (qux this)))

emits

bug.foo_bar.prototype.bug$foo_bar_p$qux$arity$1 = function() {
  return"qux"
};
bug.foo_bar.prototype.bug$foo_bar_p$baaz$arity$2 = function(a) {
  return a.bug$foo - bar - p$qux$arity$1(a)
};

Does not work, sounds like a munging issue?

[CLJS-335] user defined tagged literals in CLJS

Tue, 25 Dec 2012 13:30:55 -0600

I'm trying to make my own tagged literals for cljs, and its a rough scene. I've probably spend 15 hours trying to get this to work properly.

The quick hack of binding cljs-data-readers is a pretty bad solution, and doesn't work with cljsbuild.

One solution is to just copy the mechanism of data_readers.clj, instead calling it cljs_data_readers.clj. That would help.

A better solution is to just pass through all the tagged literals, and resolve them on the cljs side, eg `((cljs.core/get (cljs.core/deref cljs.reader/tag-table) ~tag) ~data))

That way the definition of the tags doesn't have to be repeated twice, as is done now (once in cljs.reader, and once in the clj-side cljs.tagged-literals) .

The problem with this is that clj itself is incapable of passing through undefined tags without exploding, which is also a near showstopper. Having something like cljs_data_readers.clj would get the job done in the meantime.

(another minor issue is that the cljs reader doesn't handle namespaced symbols, so in #a/b, b is what is used as the key into cljs-data-readers)

[CLJS-334] (new (some-complex-expr) ...) results in incomprehensible error

Wed, 29 Aug 2012 20:39:35 -0500

Here's a link to a conversation with kovasb on #clojure (can't seem to find it in Chouser's logs for some reason):

http://rotty.xx.vu/irclogs/freenode/%23clojure/2012-06-30/#e598

The problem is that new always fails if given a complex expression (= not a symbol) as the ctor argument. This used not to be the case in earlier ClojureScript releases; the reason it fails now is due to number-of-fields validation not guarding against the non-symbol-ctor-argument case.

I see two possible solutions: (1) restore the old behaviour while preserving the number-of-fields validation for symbolic ctor args; (2) mandate symbolic-ctor-only usage of new and throw an error with a useful message in parse 'new. I'm leaning towards (1), so the forthcoming patch takes this approach. Either approach is easy enough to implement. (I think the way parse 'new is written suggests that allowing complex ctor expressions was the original intention; I could be wrong about this though.)

[CLJS-333] Keyword self-lookups to return default value when appropriate

Tue, 3 Jul 2012 19:52:34 -0500

Originally reported by Evan Mezeske in a comment on ~~CLJS-330~~.

Due to a missing -invoke arity in cljs.core.Keyword's implementation of IFn, calls like (:foo {} 1) fail to produce the given default value.

[CLJS-332] cljs.core.UUID's equiv should check that the other object is also a UUID instance

Tue, 3 Jul 2012 19:58:55 -0500

Currently UUID instances are considered = to any object with a uuid field containing the same UUID string.

[CLJS-331] nil values in :children vector for 'try' forms

Tue, 3 Jul 2012 19:55:04 -0500

When analyzing an expression like

(try
(foo bar)
(catch js/Error e
:do-something))

the `:children` vector will contain `nil` keys (corresponding to the "missing" finally form)

[CLJS-330] (hash js/undefined) results in trouble (with implications to reasonable CLJS code)

Wed, 4 Jul 2012 10:17:58 -0500

See the ggroup thread started by Robert Marianski:

https://groups.google.com/d/topic/clojure/uGMlLCB5UHw/discussion

Here's a copy of the breaking code exhibited there:

noformat
(defmulti foo (fn [a b] [(:foo a) (:foo b)]))
(defmethod foo [:foo :bar] [a b] :foobar)
(defmethod foo :default [a b] :default)

;; this fails with an error - expecting default case
(foo {} {})
;; succeeds -> :foobar
(foo {:foo :foo} {:foo :bar})
noformat

There are further snippets which work with minor modifications.

The problem is twofold. Firstly, (:foo m) returns undefined if m is an ObjMap without a :foo key. Secondly, hash delegates to goog.Uid on undefined and the latter understandably complains.

The immediate fix is to the handling of undefined in hash.

(:foo {}) is a separate issue which should also perhaps be fixed. Then there is the bigger question of undefined handling; for example, should the REPL actually print nil when returning undefined, given that nil? currently accepts undefined? Should we have a separate null? predicate to check for the real JS null? And so on.

[CLJS-329] Cannot reference protocols using dot syntax (cljs.core.ILookup).

Sat, 30 Jun 2012 12:11:45 -0500

One used to be able to reference protocols using dot-separators; e.g.,

(satisifies? cljs.core.ILookup {:a 1}) ;;=> true

however, after CLJS commit 2aeb3d8f this is no longer possible.
These forms work correctly:

(satisfies? cljs.core/ILookup {:a 1})
(satisfies? ILookup {:a 1})

This issue came to my attention because core.match uses the cljs.core.ILookup form, so if that gets depreciated, downstream libraries will have to be updated.

[CLJS-328] Bugfix for :require spec handling in ns

Fri, 29 Jun 2012 10:49:18 -0500

(:require [lib.ns]) should be equivalent to (:require lib.ns) and (:require [lib.ns :as lib.ns]) (the latter two are correctly handled in the same way), but currently isn't due to an oversight. The forthcoming patch fixes this.

[CLJS-327] Backend agnostic repl infrastructure

Tue, 26 Jun 2012 11:34:52 -0500

This enhancement is about changing some names and docs in the repl infrastructure, so that it is backend agnostic.

The code is already backend agnostic, so the only changes that were needed are about references to Javascript.

[CLJS-326] hash-set and PersistentHashSet/fromArray == faster set construction

Mon, 25 Jun 2012 06:33:47 -0500

As discussed with mmarczyk in irc, the attached patch implements Clojure's hash-set function and modifies the compiler to create sets using a new fromArray static method. To test these, I created three new benchmarks. Here's before and after benchmark results:

$ time ./script/benchmark | grep '#{'
[], #{}, 100000 runs, 77 msecs
[], #{1 2 3}, 100000 runs, 582 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 104 msecs
[], #{}, 100000 runs, 740 msecs
[], #{1 2 3}, 100000 runs, 1809 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 221 msecs
[], #{}, 100000 runs, 281 msecs
[], #{1 2 3}, 100000 runs, 1310 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 288 msecs
./script/benchmark 109.41s user 3.82s system 127% cpu 1:28.96 total

$ time ./script/benchmark | grep '#{'
[], #{}, 100000 runs, 1 msecs
[], #{1 2 3}, 100000 runs, 333 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 100 msecs
[], #{}, 100000 runs, 1 msecs
[], #{1 2 3}, 100000 runs, 1670 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 325 msecs
[], #{}, 100000 runs, 1 msecs
[], #{1 2 3}, 100000 runs, 689 msecs
[coll #{1 2 3}], (conj coll 4), 100000 runs, 321 msecs
./script/benchmark 103.94s user 4.89s system 108% cpu 1:39.88 total
grep '#{' 0.00s user 0.00s system 0% cpu 1:39.85 total

[CLJS-325] Destructuring broken when using Clojure 1.5 alphas

Sun, 24 Jun 2012 22:04:46 -0500

destructuring macro changed - clojure.lang.PersistentHashMap/create reference added to destructure. This probably means we'll need our own destructure macro and any macros that rely on it will also need to be moved over into the core.clj macros file.

[CLJS-324] cljs.core/format

Fri, 29 Jun 2012 11:07:07 -0500

Implement cljs.core/format. Make sure there is nothing in gclosure for this. I suppose we should try to emulate the jvm version as much as that makes sense?

[CLJS-323] add :warnings :all / :none option to compiler build options

Sat, 23 Jun 2012 12:18:40 -0500

lein-cljsbuild experienced some breakage since we move things into the analyzer namespaces - cljs-warn-on-undeclared for example.

[CLJS-322] Introduce an obj-map function as an analogue of array-map

Mon, 18 Jun 2012 21:09:48 -0500

This function would be expected to produce ObjMaps of arbitrary size. ObjMaps are great for lookup speed with string keys in a wide range of sizes, so this could conceivably be useful. Additionally, ObjMaps currently are the only non-deprecated map type without a dedicated factory function.

[CLJS-321] Support with-out-str

Mon, 22 Oct 2012 18:06:13 -0500

Attached patch implements with-out-str macro in terms of goog.string.StringBuffer and print-fn via .append

The attached patch also fixes ~~CLJS-319~~

[CLJS-320] memfn not supported

Mon, 18 Jun 2012 21:01:52 -0500

The docs say "it almost always preferable to do this directly now", but this was one more thing that slowed down the porting of a small piece of JVM Clojure code for me. I'm of the opinion that parity with Clojure proper is desirable where it doesn't hurt platform interop or performance.

[CLJS-319] missing spaces when printing the same thing more than once

Thu, 5 Jul 2012 15:06:57 -0500

E.g. (println 1 1) prints "11\n" instead of "1 1\n".

Here's the culprit:
https://github.com/clojure/clojurescript/blob/master/src/cljs/cljs/core.cljs#L6136-6137

[CLJS-318] resolution conflict between var names and namespace segments

Sun, 17 Jun 2012 13:13:58 -0500

If the initial segment of the namespace of a symbol matches a var in the resolving namespace, there can be a conflict. E.g. "conflict.core/conflict" might end up compiling to "conflict.core.conflict.core.conflict" instead of "conflict.core.conflict".

In this example https://gist.github.com/ec4dce098d47268a64b3 , the problem only occurs inside a multiple-arity defn. The problem is line 4 in the compiled js, which should, I think, be "a" or "conflict.core.conflict" instead of "a.core.conflict".

[CLJS-317] Decouple the analyzer

Fri, 15 Jun 2012 11:17:56 -0500

This is an enhancement that gets the analyzer part of the compiler in its own file.

The compiler.clj file (cljs.compiler namespace) still contains everything else, namely the js emitters and compilation utility functions (compile-file et. all)

References to functions or dynamic vars now in the analyzer have been updated throughout the whole code base.

Tested with the repl and the regular compiler. Everything seems to work fine

With this patch, it should now be possible to develop alternative backends in parallel to the JS one quite easily.

[CLJS-316] Use load dynamically instead of static require to load core cljs macros

Fri, 15 Jun 2012 09:27:19 -0500

This is an enhancement that replaces the static (require 'cljs.core) with a dynamic load operation that happens when the analyzer is first called. The features are :

The load can be classpath relative or filesystem relative (a dynamic var sets wether it's one or the other)
The load happens dynamically and once when the analyzer is first ran. However, is the path is rebound, the load will happen a second time, to provides semantics in tune with the binding of a dynamic var.
Helpers macros to bind the path to be used this way :

(with-core-macros "cljs/core"
  ...)

(with-core-macros-file "src/clj/cljs/core.clj"
 ...)

Path has been tested, and helpers macros too, even if they are not used yet.

[CLJS-315] compiler bug resulting from proto inlining optimization

Thu, 14 Jun 2012 18:59:22 -0500

(ns jayq.core)

(extend-type js/jQuery
  IIndexed
  (-nth [this n]
    (when (< n (count this))
      (.slice this n (inc n))))
  (-nth [this n not-found]
    (if (< n (count this))
      (.slice this n (inc n))
      (if (undefined? not-found)
        nil
        not-found)))

  ILookup
  (-lookup
    ([this k]
       (or (.slice this k (inc k)) nil))
    ([this k not-found]
       (-nth this k not-found)                     ; <---- here if I comment and replace with 1 this will compile in advanced mode.
       ;1
       ))
  )

java.lang.ClassCastException: java.lang.String cannot be cast to clojure.lang.Named
	at clojure.core$namespace.invoke(core.clj:1497)
	at cljs.compiler$resolve_existing_var.invoke(compiler.clj:110)
	at cljs.compiler$eval1054$fn__1056.invoke(compiler.clj:716)
	at clojure.lang.MultiFn.invoke(MultiFn.java:163)
	at cljs.compiler$emit_block.invoke(compiler.clj:333)
	at cljs.compiler$emit_fn_method.invoke(compiler.clj:512)
	at cljs.compiler$eval952$fn__954.invoke(compiler.clj:573)
	at clojure.lang.MultiFn.invoke(MultiFn.java:163)
	at cljs.compiler$emits.doInvoke(compiler.clj:232)
	at clojure.lang.RestFn.invoke(RestFn.java:436)
	at cljs.compiler$eval1089$fn__1091.invoke(compiler.clj:791)
	at clojure.lang.MultiFn.invoke(MultiFn.java:163)
	at cljs.compiler$emit_block.invoke(compiler.clj:333)
	at cljs.compiler$eval996$fn__998.invoke(compiler.clj:633)
	at clojure.lang.MultiFn.invoke(MultiFn.java:163)
	at cljs.compiler$compile_file_STAR_.invoke(compiler.clj:1668)
	at cljs.compiler$compile_file.invoke(compiler.clj:1705)
	at cljs.compiler$compile_root.invoke(compiler.clj:1766)
	at cljs.closure$compile_dir.invoke(closure.clj:364)
	at cljs.closure$eval1981$fn__1982.invoke(closure.clj:396)
	at cljs.closure$eval1910$fn__1911$G__1901__1918.invoke(closure.clj:266)
	at cljs.closure$eval1968$fn__1969.invoke(closure.clj:410)
	at cljs.closure$eval1910$fn__1911$G__1901__1918.invoke(closure.clj:266)
	at cljs.closure$build.invoke(closure.clj:874)
	at user$compile_cljs.invoke(NO_SOURCE_FILE:273)
	at user$cljs_build.invoke(NO_SOURCE_FILE:284)
	at clojure.lang.AFn.applyToHelper(AFn.java:167)
	at clojure.lang.AFn.applyTo(AFn.java:151)
	at clojure.core$apply.invoke(core.clj:605)
	at clojure.core$partial$fn__4072.doInvoke(core.clj:2345)
	at clojure.lang.RestFn.invoke(RestFn.java:408)
	at user$changed_fn$fn__2184.invoke(NO_SOURCE_FILE:88)
	at user$watch.invoke(NO_SOURCE_FILE:103)
	at user$main$fn__2271.invoke(NO_SOURCE_FILE:387)
	at clojure.core$binding_conveyor_fn$fn__3989.invoke(core.clj:1819)
	at clojure.lang.AFn.call(AFn.java:18)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
	at java.util.concurrent.FutureTask.run(FutureTask.java:138)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
	at java.lang.Thread.run(Thread.java:662)

[CLJS-314] Simplify if form emission in js backend

Wed, 13 Jun 2012 16:14:01 -0500

Factor out some condition checks in emit :if , patch attached

[CLJS-313] Encapsulate namespaces access and environment creation

Wed, 13 Jun 2012 09:23:49 -0500

For the moment, the initialization of the "namespaces" atom is static in the ClojureScript compiler.

However, if we are to decouple the js backend, this initialization will need to be done dynamically, because it will have to come after the core namespace is set by the analyzer user.

The problem is that analyze environments are created by hand by the repl and the compiler for the moment, and that the "namespaces" atom is accessed and modified directly, without checking for initialization.

The patch attached encapsulates the creation of environments and the access of the namespaces atom, so that

1. Environment creation is factored
2. There is a hook to ensure proper initialization in further enhancements

[CLJS-312] Support :import

Thu, 30 Aug 2012 19:50:35 -0500

Useful for bringing in ctors.

See the ggroup discussion:

https://groups.google.com/d/topic/clojure/etFN-sdBS6c/discussion

[CLJS-311] rename-to-js regex has a non escaped "."

Mon, 11 Jun 2012 11:57:13 -0500

this can wrongly replace filenames
(rename-to-js "file.xcljs")
"file..js"

[CLJS-310] Use backend agnostic munging function for namespace resolution

Mon, 11 Jun 2012 07:23:27 -0500

ns->relpath uses the js specific munge function for path resolution.

A patch is attached that uses a backend agnostic munge function.

[CLJS-309] Bug - Typo in commit "Tagged literals in the CLJS compiler and first blush tests "

Fri, 8 Jun 2012 10:49:17 -0500

I'm pretty sure there is a typo in this commit,

cljs-data-readers is declared, but then data-readers is bound in compile-file, which makes compilation fail

Patch attached

[CLJS-308] Support types & protocols as type hints

Fri, 8 Jun 2012 18:12:55 -0500

If we have a type / protocol type hint we can direct dispatch in regular fns too.

[CLJS-307] Faster empty map creation, default to PersistentArrayMap when converting an obj-map whose lenght is less than cljs.core.PersistentArrayMap/HASHMAP_THRESHOLD

Thu, 7 Jun 2012 11:58:34 -0500

Faster empty map creation, default to PersistentArrayMap when converting an obj-map whose lenght is less than cljs.core.PersistentArrayMap/HASHMAP_THRESHOLD

[CLJS-306] Clojure.core/intern is not implemented

Sun, 17 Jun 2012 11:08:30 -0500

There is no "intern" in ClojureScript. If this is intended, it would be nice to have this documented in "Differences from Clojure" article.

[CLJS-305] direct protocol dispatch from within deftype / defrecord / extend-type

Fri, 8 Jun 2012 18:11:16 -0500

We actually have a lot of information around deftype / defrecord / extend-type. We could use this information to emit direct dispatches to protocol implementations and avoid going through protocol fns.

[CLJS-304] Comparing a js/Date to nil throws

Mon, 18 Jun 2012 20:59:50 -0500

(= (js/Date.) nil)

[CLJS-303] (case e ...) evaluates e multiple times

Wed, 6 Jun 2012 11:22:33 -0500

(case (do (pr 1) 2) 3 4 5 6 7) ; CLJS prints 117, CLJ prints 17

[CLJS-302] Implement 'clojure.core/bases'

Tue, 5 Jun 2012 13:48:48 -0500

This can be done in terms of Closure's inheritance mechanism, I guess. Example code:

(defn bases [o]
  (lazy-seq
   (when-let [ctor (and o (.-constructor o))]
     (cons ctor (bases (.-superClass_ ctor))))))

[CLJS-301] Inline instance?

Sat, 22 Dec 2012 16:33:35 -0600

See discussion on http://dev.clojure.org/jira/browse/CLJS-300

This is a low priority patch for inlining instanceof checks. I don't know if it has any significant performance improvement, but the patch was sort of a side effect of my work on ~~CLJS-300~~, so I figured I'd bundle it up and share it here in case someone wants to test it's perf impact and apply if it is a win.

[CLJS-300] RegExp objects print incorrectly

Mon, 4 Jun 2012 23:52:42 -0500

#"x" is currently printing as #</x/>

js/RegExp needs an IPrintable implementation: (-pr-seq [re _] (list "#\"" (.-source re) "\""))

Unfortunately, this is blocked by the same GClosure issue as http://dev.clojure.org/jira/browse/CLJS-68

[CLJS-299] PersistentVector push-tail, do-assoc, pop-tail should not contain recursive calls

Fri, 31 Aug 2012 09:04:24 -0500

This prevents V8 inlining. Lazlo's earlier experiments seemed to suggest ~30% gain.

[CLJS-298] CLJS-294 broke ^:export

Sun, 3 Jun 2012 22:59:34 -0500

the fix for munging broke http://dev.clojure.org/jira/browse/CLJS-294 ^:export.