don't specialize functions (#54)

Author: ZacLN

src/CSTParser.jl

@@ -174,7 +174,7 @@ Handles cases where an expression - `ret` - is not followed by
 + an expression preceded by a unary operator
 + A number followed by an expression (with no seperating white space)
 """
-function parse_compound(ps::ParseState, ret)
+function parse_compound(ps::ParseState, ret::ANY)
     if ps.nt.kind == Tokens.FOR
         ret = parse_generator(ps, ret)
     elseif ps.nt.kind == Tokens.DO

src/components/controlflow.jl

@@ -1,4 +1,4 @@
-function parse_do(ps::ParseState, ret)
+function parse_do(ps::ParseState, ret::ANY)
     kw = KEYWORD(next(ps))
 
     args = EXPR{TupleH}(Any[])

src/components/functions.jl

@@ -48,36 +48,36 @@ end
 
 Parses a function call. Expects to start before the opening parentheses and is passed the expression declaring the function name, `ret`.
 """
-function parse_call_exor(ps::ParseState, ret)
+function parse_call_exor(ps::ParseState, ret::ANY)
     arg = @precedence ps 20 parse_expression(ps)
     ret = UnarySyntaxOpCall(ret, arg)
     return ret
 end
-function parse_call_decl(ps::ParseState, ret)
+function parse_call_decl(ps::ParseState, ret::ANY)
     arg = @precedence ps 20 parse_expression(ps)
     ret = UnarySyntaxOpCall(ret, arg)
     return ret
 end
-function parse_call_and(ps::ParseState, ret)
+function parse_call_and(ps::ParseState, ret::ANY)
     arg = @precedence ps 20 parse_expression(ps)
     ret = UnarySyntaxOpCall(ret, arg)
     return ret
 end
 
 # NEEDS FIX: these are broken (i.e. `<:(a,b) where T = 1`)
-function parse_call_issubt(ps::ParseState, ret)
+function parse_call_issubt(ps::ParseState, ret::ANY)
     arg = @precedence ps 13 parse_expression(ps)
     ret = EXPR{Call}(Any[ret; arg.args])
     return ret
 end
 
-function parse_call_issupt(ps::ParseState, ret)
+function parse_call_issupt(ps::ParseState, ret::ANY)
     arg = @precedence ps 13 parse_expression(ps)
     ret = EXPR{Call}(Any[ret; arg.args])
     return ret
 end
 
-function parse_call_PlusOp(ps::ParseState, ret)
+function parse_call_PlusOp(ps::ParseState, ret::ANY)
     arg = @precedence ps 13 parse_expression(ps)
     if arg isa EXPR{TupleH}
         ret = EXPR{Call}(Any[ret; arg.args])
@@ -89,7 +89,7 @@ function parse_call_PlusOp(ps::ParseState, ret)
     return ret
 end
 
-function parse_call(ps::ParseState, ret)
+function parse_call(ps::ParseState, ret::ANY)
     if is_plus(ret) || is_minus(ret) || is_not(ret)
         return parse_call_PlusOp(ps, ret)
     elseif is_and(ret)

src/components/lists.jl

@@ -4,7 +4,7 @@ parse_tuple(ps, ret)
 `ret` is followed by a comma so tries to parse the rest of the
 tuple.
 """
-function parse_tuple(ps::ParseState, ret)
+function parse_tuple(ps::ParseState, ret::ANY)
     op = PUNCTUATION(next(ps))
 
     if closer(ps) || (isassignment(ps.nt) && ps.nt.kind != Tokens.APPROX)

src/components/loops.jl

@@ -69,7 +69,7 @@ parse_generator(ps)
 Having hit `for` not at the beginning of an expression return a generator.
 Comprehensions are parsed as SQUAREs containing a generator.
 """
-function parse_generator(ps::ParseState, ret)
+function parse_generator(ps::ParseState, ret::ANY)
     kw = KEYWORD(next(ps))
     ret = EXPR{Generator}(Any[ret, kw])
     @catcherror ps ranges = @closer ps paren @closer ps square parse_ranges(ps)

src/components/operators.jl

@@ -189,7 +189,7 @@ function parse_unary_colon(ps::ParseState, op)
 end
 
 # Parse assignments
-function parse_operator_eq(ps::ParseState, ret, op)
+function parse_operator_eq(ps::ParseState, ret::ANY, op)
     # Parsing
     @catcherror ps nextarg = @precedence ps AssignmentOp - LtoR(AssignmentOp) parse_expression(ps)
 
@@ -205,7 +205,7 @@ function parse_operator_eq(ps::ParseState, ret, op)
 end
 
 # Parse conditionals
-function parse_operator_cond(ps::ParseState, ret, op)
+function parse_operator_cond(ps::ParseState, ret::ANY, op)
     @catcherror ps nextarg = @closer ps ifop parse_expression(ps)
     @catcherror ps op2 = OPERATOR(next(ps))
     @catcherror ps nextarg2 = @closer ps comma @precedence ps 0 parse_expression(ps)
@@ -214,7 +214,7 @@ function parse_operator_cond(ps::ParseState, ret, op)
 end
 
 # Parse comparisons
-function parse_comp_operator(ps::ParseState, ret, op)
+function parse_comp_operator(ps::ParseState, ret::ANY, op)
     @catcherror ps nextarg = @precedence ps ComparisonOp - LtoR(ComparisonOp) parse_expression(ps)
     if ret isa EXPR{Comparison}
         push!(ret, op)
@@ -232,7 +232,7 @@ function parse_comp_operator(ps::ParseState, ret, op)
 end
 
 # Parse ranges
-function parse_operator_colon(ps::ParseState, ret, op)
+function parse_operator_colon(ps::ParseState, ret::ANY, op)
     @catcherror ps nextarg = @precedence ps ColonOp - LtoR(ColonOp) parse_expression(ps)
     if ret isa BinarySyntaxOpCall && is_colon(ret.op)
         ret = EXPR{ColonOpCall}(Any[ret.arg1, ret.op, ret.arg2])
@@ -248,7 +248,7 @@ end
 
 
 # Parse power (special case for preceding unary ops)
-function parse_operator_power(ps::ParseState, ret, op)
+function parse_operator_power(ps::ParseState, ret::ANY, op)
     @catcherror ps nextarg = @precedence ps PowerOp - LtoR(PowerOp) @closer ps inwhere parse_expression(ps)
 
     # Construction
@@ -269,7 +269,7 @@ end
 
 
 # parse where
-function parse_operator_where(ps::ParseState, ret, op)
+function parse_operator_where(ps::ParseState, ret::ANY, op)
     args = Any[]
     if ps.nt.kind == Tokens.LBRACE
         next(ps)
@@ -290,7 +290,7 @@ function parse_operator_where(ps::ParseState, ret, op)
 end
 
 # parse dot access
-function parse_operator_dot(ps::ParseState, ret, op)
+function parse_operator_dot(ps::ParseState, ret::ANY, op)
     if ps.nt.kind == Tokens.LPAREN
         @catcherror ps sig = @default ps @closer ps paren parse_call(ps, ret)
         args = EXPR{TupleH}(sig.args[2:end])
@@ -330,20 +330,20 @@ function parse_operator_dot(ps::ParseState, ret, op)
 end
 
 
-function parse_operator_dddot(ps::ParseState, ret, op)
+function parse_operator_dddot(ps::ParseState, ret::ANY, op)
     return UnarySyntaxOpCall(ret, op)
 end
 
-function parse_operator_prime(ps::ParseState, ret, op)
+function parse_operator_prime(ps::ParseState, ret::ANY, op)
     return UnarySyntaxOpCall(ret, op)
 end
 
-function parse_operator_anon_func(ps::ParseState, ret, op)
+function parse_operator_anon_func(ps::ParseState, ret::ANY, op)
     @catcherror ps arg = @closer ps comma @precedence ps 0 parse_expression(ps)
     return BinarySyntaxOpCall(ret, op, EXPR{Block}(Any[arg]))
 end
 
-function parse_operator(ps::ParseState, ret, op)
+function parse_operator(ps::ParseState, ret::ANY, op)
     K,dot = op.kind, op.dot
     P = precedence(K)