Clojure JIRA

[CLJS-77] Add support for Closure defines

Thu, 31 May 2012 16:32:42 -0500

The Closure compiler has "--define" which allows you to set some library values at compile time. The settable values are annotated with "@define": https://code.google.com/closure/compiler/docs/js-for-compiler.html

The particular values I was interested in were goog.dom.ASSUME_{QUIRKS,STANDARDS}_MODE because it would save some code and runtime computation if the rendering mode is known at compile time. (It turns out to be very minor for my tiny test program, but probably more substantial for things that use more of the Closure library.) goog.DEBUG also seems useful to tweak.

The attached patch supports a new compile option :define, along with a map from keys/strings to values. The Closure compiler takes a -~~define option like: "~~-define='goog.DEBUG=false'". In ClojureScript, this would be {:define {"goog.DEBUG" false}} or {:define {:goog.DEBUG false}}.

[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-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-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-113] Allow colon as whitespace in map literals

Tue, 24 Apr 2012 07:40:36 -0500

Allow colon as whitespace in map literals

[CLJS-327] Backend agnostic repl infrastructure

Tue, 26 Jun 2012 11:34:52 -0500

This enhancement is about changing some names and docs in the repl infrastructure, so that it is backend agnostic.

The code is already backend agnostic, so the only changes that were needed are about references to Javascript.

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

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

clojure.reflect should work for the Rhino REPL

[CLJS-240] Warning under advanced compilation about incorrect protocol implementation signatures

Sat, 5 May 2012 21:15:46 -0500

Warning under advanced compilation about incorrect protocol implementation signatures

[CLJS-150] Regular expressions don't support Javascript mode flags

Thu, 16 Feb 2012 15:33:59 -0600

Currently, the compiler and cljs.core allow for Java mode flags. Javascript doesn't support many of these, and supports one flag not supported by Java - 'g'.

ClojureScript regular expressions should support only Javascript regex mode flags: 'i', 'm', and 'g'. This applies to Regex literals in the compiler as well as (re-pattern).

This is a defect in the implementation of ~~CLJS-116~~.

[CLJS-246] Use protocol mask test in protocol fns

Sun, 17 Jun 2012 21:28:02 -0500

This is a performance win on many browsers.

http://jsperf.com/direct-vs-chain/8

[CLJS-247] possible protocol dispatch performance enhancement

Wed, 23 May 2012 09:57:22 -0500

We could at the call site do the bit test and call directly? Otherwise, call the slow path? Implications for code size, but perhaps this could be a flag for people who really want the performance?

[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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-27] Conditional compilation (or reading)

Fri, 27 Jul 2012 13:48:52 -0500

As people start trying to write libs that are portable between Clojure and ClojureScript they might need to have a bit of branching on target. N.B. supporting this means a change to Clojure, although it has general utility there as well.

Consider CL #+ #- reader macros - http://www.lispworks.com/documentation/lw50/CLHS/Body/02_dhq.htm

[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-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-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-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-480] cljs-data-readers is bound to data-readers inconsistently

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

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

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

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

I'm happy to do either of:

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

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

[CLJS-512] Tagged literals should yield Java types to macros

Thu, 30 May 2013 20:02:48 -0500

user=> '#inst "2000-01-01"
#inst "2000-01-01T00:00:00.000-00:00"

ClojureScript:cljs.user> '#inst "2000-01-01"
(js/Date. 946684800000)

CLJS should return a JS Date object, not a list.

This means that there needs to be a pluggable system for emitting custom types as JS code. Right now you can work around this via (defmethod cljs.analyzer/emit-constant ...)

Full discussion in IRC here: http://clojure-log.n01se.net/date/2013-05-30.html

[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-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-523] IHash not extended to js/Date

Mon, 17 Jun 2013 14:00:55 -0500

Makes for fun times, like:

cljs.user=> ((hash-map #inst "1990-01-29T00:39:33.938-00:00" 5) #inst "1990-01-29T00:39:33.938-00:00")
nil

Happy to put together a patch implementing a sane IHash impl for js/Date. Have not done so already only because js/Date does have a place in core.cljs where core protocols are being extended to host types, but IHash just isn't included; perhaps there was a reason?

[CLJS-525] Allow hashtable lookup used for numbers and strings to be extended to other built-in types

Mon, 17 Jun 2013 15:05:30 -0500

...which would enable safe extension of key cljs protocols to types without modifying their prototypes, e.g. CLJS-523.

[CLJS-3] testing spike (assert, test.generative)

Tue, 23 Aug 2011 17:38:39 -0500

Things we will need to have/work around:

clojure.walk
rethink deep-take (simple approach: omit)
- or have a bindable var for compare-depth
fully qualified name hack
eval (macro time only?)
atoms
binding
development time namespace walking, or some other way to find tests
math fns

Imported from github issue #12

[CLJS-270] Warn if ISeq is implemented and ISeqable and ICollection are not

Wed, 30 May 2012 11:16:01 -0500

Warn if ISeq is implemented and ISeqable and ICollection are not

[CLJS-287] Allow extending 'set-options' for Closure Compiler

Thu, 31 May 2012 15:52:17 -0500

Currently, ClojureScript only exposes a limited set of options to the API users. Would be nice to have a way of extending cljs.clojure/set-options to handle arbitrary options, like --define (which is already covered in CLJS-77).

[CLJS-81] cljsc :externs flag fails when opts map not quoted

Sat, 2 Jun 2012 16:48:43 -0500

For example, in the samples/hello-js directory, running the following works fine:

    cljsc src '{:optimizations :advanced :output-to "hello-extern.js" :externs ["externs.js"]}'

However, the following fails:

    cljsc src {:optimizations :advanced :externs ["./externs.js"]} > hello-extern.js

With the error message "Exception in thread "main" java.lang.IllegalArgumentException: No implementation of method: :as-file of protocol: #'clojure.java.io/Coercions found for class: clojure.lang.Symbol".

Fully qualifying the path to externs.js seems to work, BUT it actually fails by placing an exception message into the hello-externs.js file.

[CLJS-163] Using ^:extern in repl fails

Sun, 17 Jun 2012 12:19:40 -0500

ClojureScript:cljs.user> (defn ^:export a [])
"Error evaluating:" (defn a []) :as "cljs.user.a = (function a(){\nreturn null;\n});\ngoog.exportSymbol('cljs.user.a', cljs.user.a);\n"
org.mozilla.javascript.EvaluatorException: missing ; before statement (<cljs repl>#41)

nil
ClojureScript:cljs.user> (defn a [])
#<
function a() {
    return null;
}
>
ClojureScript:cljs.user>

[CLJS-295] remove the full inst literal test - adds 10 seconds to test runs when testing all the major JS engines

Sun, 17 Jun 2012 12:04:58 -0500

remove the full inst literal test - adds 10 seconds to test runs when testing all the major JS engines

[CLJS-147] Method to specify externs that should be used by the the compiler in jar-ed non-gclosure/foreign javascript libs

Wed, 4 Apr 2012 17:53:24 -0500

Please see discussion here:

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

[CLJS-61] All global vars (f.e. __dirname) of node.js should be in cljs.nodejs

Wed, 4 Apr 2012 21:52:24 -0500

To get access of all node.js goodies without using js* it would be nice to all global variables of node.js (http://nodejs.org/docs/v0.4.11/api/globals.html#process) were part of the module cljs/nodejs
Thanks

[CLJS-29] Automate pre-push testing

Wed, 4 Apr 2012 23:35:25 -0500

Document the steps to follow to test that nothing is broken before pushing changes.

Automate this process.

[CLJS-171] Implement Pods

Sun, 17 Jun 2012 12:17:14 -0500

It would be interesting to implement Pods in ClojureScript so that transients can become an implementation detail.

[CLJS-112] clojure.data.json -- Read and write JSON strings to/from clojure data structures

Fri, 16 Dec 2011 15:53:42 -0600

Reading and writing JSON is a common requirement in both server- and client-side applications. ClojureScript needs a way to transform ClojureScript data into JSON, and vice-versa.

[CLJS-186] ClojureScript wiki/The-REPL-and-Evaluation-Environments - small issues

Wed, 30 May 2012 16:26:07 -0500

I just worked through the "The REPL and Evaluation Environments" wiki page and had to make the following change to get the example to work.

— The-REPL-and-Evaluation-Environments.md.0 2012-04-19 17:40:23.000000000 -0400
+++ The-REPL-and-Evaluation-Environments.md 2012-04-19 17:40:48.000000000 -0400
@@ -57,6 +57,7 @@
<body>
<div id="content">
<script type="text/javascript" src="out/goog/base.js"></script>
+ <script type="text/javascript" src="out/goog/deps.js"></script>
<script type="text/javascript" src="foo.js"></script>
<script type="text/javascript">
goog.require('foo');

Something else I noticed was that I didn't get the "Starting server on port 9000" message.

[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-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-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-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-339] (inc nil) returns 1 instead of throwing an exception

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

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

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

[CLJS-91] cljsc does not copy dojo dependencies

Fri, 14 Oct 2011 22:05:52 -0500

When I run "cljsc.bat src > hello.js" on as program that uses Dojo it does not copy the Dojo dependencies to the out directory. If I manually copy the Dojo dependencies it works fine. I did create a dojo.jar file in the clojurescript/lib folder.

Here is the program and html:

(ns hello (:require [dojo :as dojo]))
(defn ^:export say-hello [] (dojo/place "<div>hello world</div>" (dojo/body)))

If this is really a bug as opposed to expected behavior, I can sign a CA and take a crack at fixing it.

[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-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-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-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-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-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-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-453] ArrayVector for small vectors

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

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

Use cases:

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

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

Example of such destructuring:

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

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

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

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

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

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

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

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

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

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

[CLJS-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-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-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-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-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-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-476] Reading a value from a module does not work if the module is def'ed

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

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

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

This correctly prints "value: 1"

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

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

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

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

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

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

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

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

The program is shown here:

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

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

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

$ node src/js/pr.js

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

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

$ node src/js/pr.js

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

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

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

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

[CLJS-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-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-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-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-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-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-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-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-510] Problems with :optimizations :whitespace & :output-wrapper true

Tue, 28 May 2013 10:30:10 -0500

When I have both output wrapper and :whitespace optimizations enabled, I get the following error when loading the produced output:

goog.provide("goog.string");
goog.provide("goog.string.Unicode");
goog.string.Unicode = {NBSP:"\u00a0"};
^- Uncaught TypeError: Cannot set property 'Unicode' of undefined

Any ideas on what is going wrong? The error disappears if I use :simple or :advanced optimizations or if I set :output-wrapper to false (combined with any optimization level).

[CLJS-511] The quick start guide should be written to use lein-cljsbuild

Wed, 29 May 2013 13:10:17 -0500

The first line of the quick start guide ( https://github.com/clojure/clojurescript/wiki/Quick-Start ) says:

"NOTE: The following instructions are useful if for some reason you need to use the ClojureScript compiler directly. For a more integrated workflow, Leiningen with lein-cljsbuild is recommended."

This being the case, my first impression of the page is that this isn't really a quick start guide, but a way to do things in an obsolete way. It should be updated to show the right way to get started instead of outsourcing the guide to the lein-cljsbuild page ( https://github.com/emezeske/lein-cljsbuild ) or, perhaps the quick start guide link on https://github.com/clojure/clojurescript should directly link to the lein-cljsbuild page

[CLJS-514] Coordinate with Clojure on unsigned-bit-shift-right function name

Sat, 1 Jun 2013 13:58:42 -0500

Gabriel Horner has mentioned in a comment on CLJ-827 that >>>, currently known as bit-shift-right-zero-fill in ClojureScript, will be introduced to Clojure under the name of unsigned-bit-shift-right. Presumably this means a change to the ClojureScript name is in order.

NB. bit-shift-right-zero-fill is not marked private in ClojureScript, so this would technically be a breaking change. Perhaps the old function should stick around marked deprecated for a while?

[CLJS-516] PersistentArrayMap keys uniqueness

Wed, 5 Jun 2013 08:40:59 -0500

PersistentArrayMap does not check the uniqueness of keys at init.

PersistentHashSet also affected.

cljs.user> (array-map 1 10 2 20 1 100)
{1 10, 2 20, 1 100}

cljs.user> (hash-set 1 1 2 3)
#{1 1 2 3}

Simple (dirty?) workaround - init map by assoc.

(defn array-map
  [& keyvals]
  (apply assoc cljs.core.PersistentArrayMap/EMPTY keyvals))

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

Thu, 13 Jun 2013 02:17:57 -0500

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

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

(defprotocol IFoo
(bar[this]))

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

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

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

[CLJS-522] Make REPL reflection functions synchronous

Sun, 16 Jun 2013 22:30:01 -0500

Pending CLJS-489, make it so that any "reflection" calls (doc, macroexpand, and meta so far) print/return their results synchronously, so that the REPL prompt doesn't impinge.

(Apparently goog xhr API calls can be made synchronous easily.)

[CLJS-521] Pass along compiler options added to REPL environments

Mon, 17 Jun 2013 13:44:39 -0500

Many of the compiler options (esp. :libs, :externs, etc.) that are accepted by the compiler (and commonly specified via lein-cljsbuild options) should also apply to ClojureScript REPL sessions. Since all known IJavaScriptEnv implementations are records, the most straightforward way to do this is to allow one to add such options to REPL environment records, which can then be passed on to the compiler in cljs.repl.

Making this change has had a big impact on my personal ClojureScript productivity. Interested in the patch?

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

Tue, 18 Jun 2013 09:14:49 -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-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-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-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-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("").

Clojure JIRA

[CLJS-77] Add support for Closure defines

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

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

[CLJS-299] PersistentVector push-tail, do-assoc, pop-tail should not contain recursive calls

[CLJS-113] Allow colon as whitespace in map literals

[CLJS-327] Backend agnostic repl infrastructure

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

[CLJS-240] Warning under advanced compilation about incorrect protocol implementation signatures

[CLJS-150] Regular expressions don't support Javascript mode flags

[CLJS-246] Use protocol mask test in protocol fns

[CLJS-247] possible protocol dispatch performance enhancement

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

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

[CLJS-404] Automate Browser REPL testing

[CLJS-399] Lazy initialize global-hierarchy

[CLJS-410] support ^:expose annotation

[CLJS-145] Cannot create more than one browser evaluation environment

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

[CLJS-335] user defined tagged literals in CLJS

[CLJS-5] Compiler should emit optional source maps

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

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

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

[CLJS-456] Function named same as ns fails

[CLJS-449] stack traces for ex-info

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

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

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

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

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

[CLJS-497] Constant literal optimization

[CLJS-27] Conditional compilation (or reading)

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

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

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

[CLJS-507] Persistent Data Structure Benchmark

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

[CLJS-512] Tagged literals should yield Java types to macros

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

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

[CLJS-523] IHash not extended to js/Date

[CLJS-525] Allow hashtable lookup used for numbers and strings to be extended to other built-in types

[CLJS-3] testing spike (assert, test.generative)

[CLJS-270] Warn if ISeq is implemented and ISeqable and ICollection are not

[CLJS-287] Allow extending 'set-options' for Closure Compiler

[CLJS-81] cljsc :externs flag fails when opts map not quoted

[CLJS-163] Using ^:extern in repl fails

[CLJS-295] remove the full inst literal test - adds 10 seconds to test runs when testing all the major JS engines

[CLJS-147] Method to specify externs that should be used by the the compiler in jar-ed non-gclosure/foreign javascript libs

[CLJS-61] All global vars (f.e. __dirname) of node.js should be in cljs.nodejs

[CLJS-29] Automate pre-push testing

[CLJS-171] Implement Pods

[CLJS-112] clojure.data.json -- Read and write JSON strings to/from clojure data structures

[CLJS-186] ClojureScript wiki/The-REPL-and-Evaluation-Environments - small issues

[CLJS-338] Incorrect implementation of IReduce by ArrayChunk

[CLJS-13] Implement ratios

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

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

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

[CLJS-91] cljsc does not copy dojo dependencies

[CLJS-167] Allow exiting CLJS repl with EOF/ctrl-D as well as :cljs/quit

[CLJS-210] Implement Var form, var-get, and var? in CLJS

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

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

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

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

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

[CLJS-453] ArrayVector for small vectors

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

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

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

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

[CLJS-412] Undeclared warning when defining protocols

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

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

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

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

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

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

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