The clojarse-js from mattfenwick

make more informative error messages

more informative than, for instance, 'oops'

parse dispatches to constructors

example:

#java.lang.String["abc"]

that is valid syntax for a call to a java constructor, or something defined with deftype or defrecord

make token errors easier to find

instead of leaving them in the tree, why not:

put them in a dictionary
yank them out of the tree, leaving a pointer to the dictionary

rationale: won't have to traverse the tree to find the errors. Can just look in the dictionary

add close position to syntax trees

currently, just tracking the start position (line/column)

character octal escape -- upper limit

must be <= 255

should this be done here, in the parser? or can it be left for later tree-checkers?

implement parse tree syntax in a module

motivation: I'm using this syntax definition in multiple places (normal modules as well as test modules), might as well factor it out

description: somewhere between the CST -- b/c tree is "cleaned" -- and AST

wrong positions are getting passed in to start some of the token parsers

the position passed in is of the 1st " in "abc"

but, the token parsing starts at the a in "abc"

this is because the delimiters " are assumed to already be correct by the time token parsing is started

clarify responsibilities of each stage

what is and isn't checked? when are checks performed? what happens if there's an error?

bring back or migrate the symbol error-checking

was:

var symbol_pattern = /^([:]?)([^\d\/].*\/)?(\/|[^\d\/][^\/]*)$/;
// a translation of either of these two, which should be equivalent (from Java):
//   - [:]?([\\D&&[^/]].*/)?(/|[\\D&&[^/]][^/]*)
//   - [:]? ([^0-9/].*/)? (/|[^0-9/][^/]*)

// check for special error cases (maybe match against regex as in Clojure implementation)
// TODO this could go in Clolint instead
_checks = bind(get, function(chars) {
    console.log('chars -- ' + JSON.stringify(chars));
    if ( cs[cs.length - 1] === ':' ) {
        return cut('identifier may not end with a :', zero);
    }
    if ( cs.slice(1).indexOf('::') > -1 ) {
        return cut(':: is illegal in identifiers (except at beginning)', zero);
    }
    var match = cs.match(symbol_pattern);
    if ( match === null ) {
        return cut('invalid identifier for mysterious reasons', zero);
    } else if ( match[2] !== void 0 ) {
        var m = match[2];
        if ( m.slice(m.length - 2) === ':/' ) {
                return cut(':/ is sometimes illegal in identifiers', zero);
        }
    }
    return pure(null);
}),

specify AST for things nested under tokens

examples:

$ echo '1.2e+31 "\u1234 \n \12"' | node main.js
clojure at 1,1
  float at 1,1
    {"sign":null,"int":"1","decimal":"2","exponent":{"sign":"+","power":"31"},"suffix":null}
  string at 1,9
    {"value":[{"pos":[1,11],"kind":"unicode","value":"1234"}," ",{"pos":[1,18],"kind":"simple","value":"n"}," ",{"pos":[1,21],"kind":"octal","value":"12"}]}

the exponents in floats and the escapes in strings