Clojure JIRA

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

Tue, 21 May 2013 05:51:11 -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-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-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-480] cljs-data-readers is bound to data-readers inconsistently

Fri, 17 May 2013 17:25:23 -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-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-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-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-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-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-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-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-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-367] doseq & for macros should support chunked seqs

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

doseq & for macros should support chunked seqs

[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-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-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-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-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-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-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-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-488] aliased keywords do not work

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

The folks from Pedestal encountered this.

[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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-257] optimize dead code elimination

Wed, 20 Feb 2013 08:43:49 -0600

When compiling some code I noticed that cljs.core.apply doesn't get removed, I suspect this may trigger other fns to also not get eliminated. Needs investigation.

[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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-5] Compiler should emit optional source maps

Sat, 22 Dec 2012 16:29:56 -0600

== New Notes ==

http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/

Source map support will be landing in Chrome in 6 weeks.

== Old Notes ==

Google's debugging tooling consists of at least these two big pieces:

The `--create_source_map` compiler flag, which generates a table mapping source JS to compiled JS
The [Closure Inspector](http://code.google.com/closure/compiler/docs/inspector.html), a Firefox plugin that uses the source maps to provide error messages pointing to original code instead of compiled code

Open Questions

What does integrating with Closure Inspector look like?
Can we use code from gclosure to generate our own cljs �� compiled JS mappings?
Would we need to modify Closure Inspector?

Imported from github issue #31

[CLJS-160] Reserved words not escaped in namespace names

Sat, 22 Dec 2012 16:29:34 -0600

Example:

(ns foo.interface)

Since "interface" is a reserved word in JavaScript, any attempt to use functions in this namespace fails in the Google Closure Compiler with the message "ERROR - Parse error. missing name after . operator."

[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-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-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-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-179] (ns 'foo) throws REPL into infinite loop

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

At a ClojureScript REPL (Rhino or browser-connected), accidentally quoting the argument to ns yields a neverending stream of error messages:

ClojureScript:cljs.user> (ns 'whoops)

ClojureScript:(quote whoops)> clojure.lang.Cons cannot be cast to clojure.lang.Symbol
ClojureScript:(quote whoops)> clojure.lang.Cons cannot be cast to clojure.lang.Symbol
ClojureScript:(quote whoops)> clojure.lang.Cons cannot be cast to clojure.lang.Symbol
ClojureScript:(quote whoops)> clojure.lang.Cons cannot be cast to clojure.lang.Symbol
...

[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-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-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-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-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-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-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-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-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-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-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-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-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-145] Cannot create more than one browser evaluation environment

Fri, 7 Dec 2012 08:57:21 -0600

When testing multi-user applications, it may be desirable to run multiple browser-connected REPLs from the same Clojure process. Currently, the socket connection for the browser-connected REPL is stored in a global atom, so it is not possible to create multiple browser-connected REPLs on different ports.

[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-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-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-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-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-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-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-245] Property and method access on js/window

Wed, 28 Nov 2012 12:06:59 -0600

I noticed the following behaviour:

(.encodeURIComponent js/window "some text")

will fail under advanced compilation because the method name is optimised
This applies to any property or method of js/window.
The same does not appear to be true of js/document.

workaround as follows:

(def encode (aget js/window "encodeURIComponent"))
(encode "some txt")

[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-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-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-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-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-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-282] When compiling incrementally, goog dependencies can get out of order (breaks builds)

Mon, 19 Nov 2012 13:37:01 -0600

In lein-cljsbuild version 0.2.0, I changed it to allow incremental compilation again. Previous versions would always clean out the :output-dir before each call to closure/build, because I had seen weird issues before but never tracked them down.

Finally, I have pinpointed the problem with incremental compilation (although not the solution). The problem is that sometimes, when the compiler notices that a ClojureScript file has already been compiled to JavaScript, its JavaScript output will be inserted into the :whitespace (or higher) optimized output in the wrong order. By "wrong order", I mean its goog.provide() comes after a goog.require() for that same namespace.

I've attached a snippet from my :whitespace compiled output for a closed source project. I removed a bunch of code from the attachment, but I did not change the order of anything. As you can see, ss_charts.crossover.url is provided after it is required.

My guess is that the problem originates in compiler/compile-file. It calls requires-compilation?, and returns a hash containing only {:file ...} if it does not require compilation. I assume that the problem has to do with the fact that this hash lacks the :provides and :requires keys, and thus down the road doesn't get considered in the dependency graph correctly.

[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-401] top level let emits vars without namespace

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

top level let emits vars without namespace

[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-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-210] Implement Var form, var-get, and var? in CLJS

Sun, 28 Oct 2012 21:03:58 -0500

See discussion of Vars in CLJS here: http://dev.clojure.org/display/design/Dynamic+Binding
My goal is to eventually implement dynamic scope capture, via bound-fn and friends. The attached patch is a step in that direction.

This patch adds support for parsing the (var foo) form. The #' reader macro is provided by JVM Clojure.

#'foo emits code to construct a Var object. In this patch, each invocation of 'var will create a unique Var object. This means they are '= by fully qualified symbol, but not 'identical?. Simple memoization would fix that, but I'm not going to bother until I get to Dynamic Var objects.

The main advantage of this level of Var support is for the interactive development convenience of being able to defer dereferencing top-levels. For example, (def fog (comp f #'g)) will pick up redefinitions of 'g, but not of 'f.

[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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-388] expose :output-wrapper compile option

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

expose :output-wrapper compile option

[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-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-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-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-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-148] No way to initialize Closure class without a namespace prefix

Tue, 9 Oct 2012 16:38:43 -0500

As far as I can tell, there is no way to initialize a Closure class without using a namespace prefix.
That's very confusing to me: I know "MyClass" is an object, and I expect ClojureScript to translate "(MyClass. 0)" to "new MyClass(0);".

This issue also raises the question of how to import constructors with the :use syntax.
I can import static methods from MyClass in the usual fashion, but there's no way to get the constructor.
Do we need to write :import for ClojureScript namespaces?

goog.provide('MyClass');
/**
* @constructor
*/
MyClass = function(x){this.x = x;};
MyClass.static_method = function(){return "I'm static!";};

(ns custom
  (:require [MyClass :as X]
            [a.AnotherClass :as Y]))

(MyClass. 0) ;;Nope
(X. 0) ;;Nope
(X/static-method 1 2 3) ;;Okay

(a/AnotherClass. 0) ;;Okay
(Y. 0) ;;Nope

[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-167] Allow exiting CLJS repl with EOF/ctrl-D as well as :cljs/quit

Mon, 8 Oct 2012 11:20:23 -0500

The CLJS repl is not a perfectly well-behaved command-line tool, in that it does not respect the convention of quitting by sending an EOF character with ctrl-D. This must be causing a small amount of irritation to everyone who uses the repl and is used to the customary amenities of any command-line tool; we could ease a little bit of frustration by supporting EOF.

I've attached a patch to improve this behavior, without affecting anything else.

[CLJS-197] Minor additions to clojure.browser.dom

Sun, 30 Sep 2012 10:14:48 -0500

These two patches add clojure.browser.dom/remove-node and some missing docstrings to clojure.browser.dom.

What else can be done in this namespace? I don't want to break things, but I think some functions (log, click) don't really belong there.

[CLJS-101] Node fails with :whitespace, works with :simple

Sat, 29 Sep 2012 17:36:29 -0500

Running the example from http://mmcgrana.github.com/2011/09/clojurescript-nodejs.html. Node fails if using :whitespace optimizations, but works when using :simple. The problem seems to be missing object literals.

The source is:

$ cat src/testing-cljs-node/hello.cljs 
(ns testing-cljs-node.hello)

(defn start [& _]
  (println "Hello World!"))

(set! *main-cli-fn* start)

Here is the compilation that results in the broken code:

$ cljsc src/testing-cljs-node/hello.cljs '{:optimizations :whitespace :pretty-print true :target :nodejs}' > out/hello.js
$ node out/hello.js

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
              ^
TypeError: Cannot set property 'Unicode' of undefined
    at Object.<anonymous> (/Users/ulrik/Source/testing-cljs-node/out/hello.js:487:21)
    at Module._compile (module.js:432:26)
    at Object..js (module.js:450:10)
    at Module.load (module.js:351:31)
    at Function._load (module.js:310:12)
    at Array.0 (module.js:470:10)
    at EventEmitter._tickCallback (node.js:192:40)

When changing the optimizations to :simple, however, it works:

$ cljsc src/testing-cljs-node/hello.cljs '{:optimizations :simple :pretty-print true :target :nodejs}' > out/hello.js
$ node out/hello.js
The "sys" module is now called "util". It should have a similar interface.
Hello World!

The offending line 487 in the :whitespace code:

goog.provide("goog.string");
goog.provide("goog.string.Unicode");
goog.string.Unicode = {NBSP:"\u00a0"};  // line 487

In the working :simple code, the corresponding lines looks like this:

goog.string = {};
goog.string.Unicode = {NBSP:"\u00a0"};  // line 367

If I fix that by adding a line that creates the object, I get another error on line 901:

goog.provide("goog.userAgent.jscript");
goog.require("goog.string");
goog.userAgent.jscript.ASSUME_NO_JSCRIPT = false;  // line 901

In the working code, it looks like this:

goog.userAgent = {};
goog.userAgent.jscript = {};
goog.userAgent.jscript.ASSUME_NO_JSCRIPT = !1;  // line 683

And if I fix that, I get another error on line 975:

goog.provide("goog.debug.Error");
goog.debug.Error = function(opt_msg) {  // line 975

The working code:

goog.debug = {};
goog.debug.Error = function(a) {  // line 730

etc etc

[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-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-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-151] clojure.string/blank? improvement

Fri, 28 Sep 2012 17:48:33 -0500

The current implementation of clojure.string/blank? is verbose and redundant. GClosure provides a direct equivalent in goog.string.isEmptySafe. We should just wrap that function.

[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-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-288] Compilation of unordered collections

Sun, 23 Sep 2012 19:40:17 -0500

Given:

(defn f [x] (println x) x)

{(f 5) (f 10), (f :x) (f :y)}

Clojure produces:

5
10
:x
:y

{5 10, :x :y}

ClojureScript produces:

5
:x
10
:y

{5 10, :x :y}

[CLJS-276] Uploaded closure-library-third-party JAR not working as expected

Fri, 21 Sep 2012 07:41:58 -0500

After adding a dependency on closure-library-third-party jar to my project (as announced via http://osdir.com/ml/clojure/2012-05/msg00568.html) I was unable to use either goog.dom.query or the non third party resources.

Example error messages:
ERROR - required "goog.ui.TabBar" namespace never provided
ERROR - required "goog.dom.query" namespace never provided

It could be that its my setup, but I noticed that the JAR files look nothing like the JAR files I've generated in the past when working with closure library / compiler.

I have locally fudged the uploaded jar's such that they work as expected for my project, namely.
1) deps.js in closure-library at the very end refers to ../third-party, this path does not / could not appear in the jar provided, instead it should look like for example:
goog.addDependency('dojo/dom/query.js', ['goog.dom.query'], ['goog.array', 'goog.dom', 'goog.functions', 'goog.string', 'goog.userAgent']);
(that it to say, remove the relative path and make it look like the other dep lines)
2) removed deps.js and base.js from the -third-party jar entirely.

I readily agree that having no mention of third-party in the main jar deps.js and only referring to it in third-party.jar is prettier, but AFAIU closure compiler expects a single deps.js with all dependencies and IIRC will not merge multiple partial deps files (not sure about this, didn't test well enough). This behavior seems to be borne out by the addition of a third-party dependency resulting in existing libraries no longer working.

Possibly nicer than my solution would be to have a deps.js skipping the third party deps present in google-closure-library.jar but for google-closure-library-third-party.jar to have the full set of both, however I had no time to try this option.

[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-37] A way to create js objects and arrays from cljs maps and vectors, without copying if possible.

Tue, 18 Sep 2012 00:29:55 -0500

There's currently no convenient way to create a js object from a map. Arrays can be created using the `array` function, but this always creates a copy. In cases where you know the object or array will not be modified, it would be a shame to still pay for a copy of the object. This is especially true when the cljs map or vector is a literal such that nothing else can have a reference to it anyway.

[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-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-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-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-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-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-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-13] Implement ratios

Mon, 3 Sep 2012 15:30:19 -0500

Clojure.java contains support for Ratio types. It would be nice to have them in Clojurescript as well, but as far as I can tell this would be new development (please comment if I'm wrong). That is, there is no implementation of Ratio types in GClosure so this feature would need to be implemented from the ground up. In additional to the Ratio type, the following corresponding functions would also need implementations:

`ratio?`
`numerator`
`denominator`
`rationalize`

Plus the ratio type would need to be rolled into the existing mathematical frameworkings.

Imported from github issue #66

[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-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-60] mod not correctly implemented visavi negative num or div

Fri, 31 Aug 2012 09:44:11 -0500

user=> (map #(mod % 2) (range -2 3))
(0 1 0 1 0)
user=> (map #(mod % -2) (range -2 3))
(0 -1 0 -1 0)

ClojureScript:cljs.user> (map #(mod % 2) (range -2 3))
(0 -1 0 1 0)
ClojureScript:cljs.user> (map #(mod % -2) (range -2 3))
(0 -1 0 1 0)

[CLJS-142] ClojureScript reader throws TypeError when map keys start with colon then number

Fri, 31 Aug 2012 09:43:11 -0500

ClojureScript:cljs.user> (cljs.reader/read-string "{:9k true}")
"Error evaluating:" (cljs.reader/read-string "{:9k true}") :as "cljs.reader.read_string.call(null,\"{:9k true}\");\n"
#<TypeError: Cannot read property 'length' of null>
TypeError: Cannot read property 'length' of null
    at http://localhost:8080/javascripts/out/cljs/reader.js:530:38
    at http://localhost:8080/javascripts/out/cljs/reader.js:534:2
    at read_keyword (http://localhost:8080/javascripts/out/cljs/reader.js:547:2)
    at read_delimited_list (http://localhost:8080/javascripts/out/cljs/reader.js:373:32)
    at read_map (http://localhost:8080/javascripts/out/cljs/reader.js:418:47)
    at read (http://localhost:8080/javascripts/out/cljs/reader.js:675:115)
    at read_string (http://localhost:8080/javascripts/out/cljs/reader.js:707:25)
    at eval at <anonymous> (http://localhost:8080/javascripts/out/clojure/browser/repl.js:21:158)
    at eval at <anonymous> (http://localhost:8080/javascripts/out/clojure/browser/repl.js:21:158)
    at http://localhost:8080/javascripts/out/clojure/browser/repl.js:21:153
nil

[CLJS-69] Calling count on args passed to a nodejs main function returns an incorrect number

Fri, 31 Aug 2012 09:41:31 -0500

This is an interesting one.

(defn -main [& args]
  (prn (count args)))

(set! *main-cli-fn* -main)

No matter how many arguments you pass to this application, count always says there are two more. The arguments appear to be fine upon inspection, it's just the count that is incorrect. I investigated a bit and noticed that node passes two extra arguments that are always dropped before being passed to -main.

(prn (count (drop 2 (seq (.argv nodejs/process)))))

I tried the above and was surprised to find out that the count was correct.

[CLJS-109] Compiler errors/warnings should be displayed when cljs namespace 'package' names start with an unacceptable javascript symbol.

Fri, 31 Aug 2012 09:40:24 -0500

Clojurescript namespaces are extremely flexible. The generated javascript symbol names are not. ie:

cljs:
[code]
(ns canvas.context.2d)

(defn ^:export create-image-data
([canvas image-data] (.createImageData image-data))
([canvas sw sh] (.createImageData canvas sw sh)))
[/code]

generated js:
[code]
goog.provide('canvas.context.2d');
goog.require('cljs.core');
canvas.context.2d.create_image_data = (function() {
var create_image_data = null;
var create_image_data__2432 = (function (canvas,image_data){ return image_data.createImageData(); });
var create_image_data__2433 = (function (canvas,sw,sh){ return canvas.createImageData(sw,sh); });
create_image_data = function(canvas,sw,sh){
switch(arguments.length){ case 2 : return create_image_data__2432.call(this,canvas,sw); case 3 : return create_image_data__2433.call(this,canvas,sw,sh); }
throw('Invalid arity: ' + arguments.length);
};
return create_image_data;
})()
;
goog.exportSymbol('canvas.context.2d.create_image_data', canvas.context.2d.create_image_data);[/code]

Note the symbol name "canvas.context.2d.create_image_data". Because of the "2d" namespace name, the javascript generated is invalid.

This can simply be resolved by renaming the namespace but some notification to the developer during the compilation stage should help avoid unnecessary problems.

[CLJS-203] == has different semantics than in Clojure (and than the documentation indicates)

Fri, 31 Aug 2012 09:34:32 -0500

Clojure:

user=> (== "1" "1")
ClassCastException java.lang.String cannot be cast to java.lang.Number clojure.lang.Numbers.equiv (Numbers.java:206)

ClojureScript:

cljs.user> (== "1" "1")
true
cljs.user> (== :a :a)
true

This is rather unsettling behavior which makes the difference between (=) and (==) quite hard to understand when trying out CLJS without knowing Clojure beforehand and the only documentation available is Clojure's.

CLJS code tested on http://himera.herokuapp.com/index.html

[CLJS-277] Thorough review and removal of non-lifted local fns

Fri, 31 Aug 2012 09:32:21 -0500

We should be particularly vigilant of cases in the persistent data structures as unlifted local fns kill perf.

[CLJS-273] support ^Fn type hint

Fri, 31 Aug 2012 09:30:50 -0500

internal reduce is slower than it could be, for operations like + we need to go through the wrapper and check the arguments object etc. If a binding is type hinted as IFn we could do a runtime property check for the specify arity case and dispatch directly falling back on the normal behavior if the property is not found.

[CLJS-286] optimize regex operations

Fri, 31 Aug 2012 09:29:53 -0500

Kevin Lynagh has mentioned that CLJS regex performance is particularly bad compared to JavaScript - we should investigate.

[CLJS-297] Eliminate :meta, :vector, :set, and :map ops

Fri, 31 Aug 2012 09:24:51 -0500

The attached patch eliminates the :meta, :set, :vector, and :map ops.

These four operations can be defined more simply in terms of
calls to with-meta, set, vector, and hash-map respectively.

The compiler was optimizing construction of vectors and maps. Now,
those optimizations are implemented as macros. Additionally, sets
are optimized in much the same way.

3 files changed, 52 insertions, 99 deletions

Also worth mentioning: as macros instead of ops & emit methods, these optimizations can apply to any backend. The macros create ClojureScript forms, rather than manually generating JavaScript.

[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-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-180] Function params shadow top-level namespace segments

Thu, 30 Aug 2012 22:27:15 -0500

Given the following ClojureScript:

(ns foo)

(defn bar [] 42)

(ns baz
  (:require [foo :as x]))

(defn quux [foo]
  (x/bar))

baz.quux compiles to:

baz.quux = function quux(foo) {
  return foo.bar.call(null)
};

i.e. the parameter name shadows the top-level "foo" namespace.

[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-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-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-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-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-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-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-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-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-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-289] Represent ast :children as a vector of keys

Wed, 29 Aug 2012 00:09:12 -0500

See discussion here: https://groups.google.com/d/topic/clojure-dev/vZLVKmKX0oc/discussion

Summary: Duplication of ast nodes in various keys and in :children is problematic for some users. In particular, it doesn't play nicely with printing. A solution is needed which preserves "The AST is data. Period."

The attached patch makes no changes to how the sub nodes are currently stored outside of the :children key. Instead, it replaces :children values with a vector of keys into the main ast node. This preserves child ordering and allows a children function to be defined as:

(defn children [ast]
(mapcat #(if (coll? %) % [%]) ((apply juxt (:children ast)) ast)))

The attached patch has two caveats: 1) Many (but not all?) blocks will now be present in the children hierarchy as 'do forms. 2) Interleaved forms are intentionally bugged with respect to ordering. The :children vector for those forms match the actual behavior, not the expected behavior. This can be fixed along with http://dev.clojure.org/jira/browse/CLJS-288

[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-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-351] replace .-length usage with alength

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

replace .-length usage with alength

[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-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-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-343] make clojure.reflect fns conform to standard names

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

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