Merge pull request #15524 from JuliaLang/jb/comparisonparse

fix #9503 plus another proposal on comparison and iteration syntax

NEWS.md

@@ -32,6 +32,12 @@ Language changes
  * A warning is always given when a method is overwritten (previously, this was done only when the new
  and old definitions were in separate modules) ([#14759]).
 
+ * `A <: B` is parsed as `Expr(:(<:), :A, :B)` in all cases ([#9503]). This also applies to the
+ `>:` operator.
+
+ * Simple 2-argument comparisons like `A < B` are parsed as calls intead of using the
+ `:comparison` expression type.
+
 Command-line option changes
 ---------------------------
 
@@ -1690,6 +1696,7 @@ Too numerous to mention.
 [#9434]: https://github.com/JuliaLang/julia/issues/9434
 [#9452]: https://github.com/JuliaLang/julia/issues/9452
 [#9487]: https://github.com/JuliaLang/julia/issues/9487
+[#9503]: https://github.com/JuliaLang/julia/issues/9503
 [#9569]: https://github.com/JuliaLang/julia/issues/9569
 [#9575]: https://github.com/JuliaLang/julia/issues/9575
 [#9578]: https://github.com/JuliaLang/julia/issues/9578
@@ -1793,4 +1800,6 @@ Too numerous to mention.
 [#14469]: https://github.com/JuliaLang/julia/issues/14469
 [#14759]: https://github.com/JuliaLang/julia/issues/14759
 [#14798]: https://github.com/JuliaLang/julia/issues/14798
+[#15192]: https://github.com/JuliaLang/julia/issues/15192
 [#15242]: https://github.com/JuliaLang/julia/issues/15242
+[#15258]: https://github.com/JuliaLang/julia/issues/15258

base/linalg/cholesky.jl

@@ -276,15 +276,15 @@ end
 
 function det(C::Cholesky)
  dd = one(eltype(C))
- for i in 1:size(C.factors,1) dd *= abs2(C.factors[i,i]) end
+ for i in 1:size(C.factors,1); dd *= abs2(C.factors[i,i]) end
  dd
 end
 
 det(C::CholeskyPivoted) = C.rank < size(C.factors, 1) ? real(zero(eltype(C))) : prod(abs2(diag(C.factors)))
 
 function logdet(C::Cholesky)
  dd = zero(eltype(C))
- for i in 1:size(C.factors,1) dd += log(C.factors[i,i]) end
+ for i in 1:size(C.factors,1); dd += log(C.factors[i,i]) end
  dd + dd # instead of 2.0dd which can change the type
 end
 

base/linalg/dense.jl

@@ -248,7 +248,7 @@ function expm!{T<:BlasFloat}(A::StridedMatrix{T})
  LAPACK.gesv!(V-U, X)
 
  if s > 0 # squaring to reverse dividing by power of 2
- for t=1:si X *= X end
+ for t=1:si; X *= X end
  end
  end
 
@@ -264,10 +264,10 @@ function expm!{T<:BlasFloat}(A::StridedMatrix{T})
  end
 
  if ilo > 1 # apply lower permutations in reverse order
- for j in (ilo-1):-1:1 rcswap!(j, Int(scale[j]), X) end
+ for j in (ilo-1):-1:1; rcswap!(j, Int(scale[j]), X) end
  end
  if ihi < n # apply upper permutations in forward order
- for j in (ihi+1):n rcswap!(j, Int(scale[j]), X) end
+ for j in (ihi+1):n; rcswap!(j, Int(scale[j]), X) end
  end
  X
 end

base/sparse/cholmod.jl

@@ -1517,7 +1517,7 @@ end
 function logdet{Tv<:VTypes}(F::Factor{Tv})
  f = unsafe_load(get(F.p))
  res = zero(Tv)
- for d in diag(F) res += log(abs(d)) end
+ for d in diag(F); res += log(abs(d)) end
  f.is_ll!=0 ? 2res : res
 end
 

base/sparse/linalg.jl

@@ -6,14 +6,14 @@ import Base.LinAlg: checksquare
 
 # Convert from 1-based to 0-based indices
 function decrement!{T<:Integer}(A::AbstractArray{T})
- for i in 1:length(A) A[i] -= one(T) end
+ for i in 1:length(A); A[i] -= one(T) end
  A
 end
 decrement{T<:Integer}(A::AbstractArray{T}) = decrement!(copy(A))
 
 # Convert from 0-based to 1-based indices
 function increment!{T<:Integer}(A::AbstractArray{T})
- for i in 1:length(A) A[i] += one(T) end
+ for i in 1:length(A); A[i] += one(T) end
  A
 end
 increment{T<:Integer}(A::AbstractArray{T}) = increment!(copy(A))

base/sparse/sparsematrix.jl

@@ -3119,7 +3119,7 @@ spdiagm(B::AbstractVector, d::Number=0) = spdiagm((B,), (d,))
 function expandptr{T<:Integer}(V::Vector{T})
  if V[1] != 1 throw(ArgumentError("first index must be one")) end
  res = similar(V, (Int64(V[end]-1),))
- for i in 1:(length(V)-1), j in V[i]:(V[i+1] - 1) res[j] = i end
+ for i in 1:(length(V)-1), j in V[i]:(V[i+1] - 1); res[j] = i end
  res
 end
 

base/strings/basic.jl

@@ -39,7 +39,7 @@ getindex(s::AbstractString, i::Integer) = s[Int(i)]
 getindex{T<:Integer}(s::AbstractString, r::UnitRange{T}) = s[Int(first(r)):Int(last(r))]
 # TODO: handle other ranges with stride ±1 specially?
 getindex(s::AbstractString, v::AbstractVector) =
- sprint(length(v), io->(for i in v write(io,s[i]) end))
+ sprint(length(v), io->(for i in v; write(io,s[i]) end))
 
 symbol(s::AbstractString) = symbol(bytestring(s))
 

base/test.jl

@@ -151,6 +151,11 @@ Returns a `Pass` `Result` if it does, a `Fail` `Result` if it is
 """
 macro test(ex)
  orig_ex = Expr(:quote,ex)
+ # Normalize comparison operator calls to :comparison expressions
+ if isa(ex, Expr) && ex.head == :call && length(ex.args)==3 &&
+ Base.operator_precedence(ex.args[1]) == Base.operator_precedence(:(==))
+ ex = Expr(:comparison, ex.args[2], ex.args[1], ex.args[3])
+ end
  # If the test is a comparison
  if isa(ex, Expr) && ex.head == :comparison
  # Generate a temporary for every term in the expression

src/julia-parser.scm

@@ -780,12 +780,21 @@
  (let loop ((ex (parse-pipes s))
  (first #t))
  (let ((t (peek-token s)))
- (if (not (is-prec-comparison? t))
- ex
- (begin (take-token s)
- (if first
- (loop (list 'comparison ex t (parse-pipes s)) #f)
- (loop (append ex (list t (parse-pipes s))) #f)))))))
+ (cond ((is-prec-comparison? t)
+ (begin (take-token s)
+ (if first
+ (loop (list 'comparison ex t (parse-pipes s)) #f)
+ (loop (append ex (list t (parse-pipes s))) #f))))
+ (first ex)
+ ((length= ex 4)
+ ;; only a single comparison; special chained syntax not required
+ (let ((op (caddr ex))
+ (arg1 (cadr ex))
+ (arg2 (cadddr ex)))
+ (if (or (eq? op '|<:|) (eq? op '|>:|))
+ `(,op ,arg1 ,arg2)
+ `(call ,op ,arg1 ,arg2))))
+ (else ex)))))
 
 (define closing-token?
  (let ((closer? (Set '(else elseif catch finally #\, #\) #\] #\} #\;))))
@@ -905,13 +914,6 @@
  (else
  ex)))))
 
-;; convert (comparison a <: b) to (<: a b)
-(define (subtype-syntax e)
- (if (and (pair? e) (eq? (car e) 'comparison)
- (length= e 4) (eq? (caddr e) '|<:|))
- `(<: ,(cadr e) ,(cadddr e))
- e))
-
 (define (parse-unary-prefix s)
  (let ((op (peek-token s)))
  (if (syntactic-unary-op? op)
@@ -1031,8 +1033,7 @@
  (string (deparse ex) " " (deparse t))
  (string (deparse ex) (deparse t))))
  (take-token s)
- (loop (list* 'curly ex
- (map subtype-syntax (parse-arglist s #\} )))))
+ (loop (list* 'curly ex (parse-arglist s #\} ))))
  ((#\")
  (if (and (symbol? ex) (not (operator? ex))
  (not (ts:space? s)))
@@ -1066,7 +1067,7 @@
  " expected \"end\", got \"" t "\""))))))
 
 (define (parse-subtype-spec s)
- (subtype-syntax (parse-comparison s)))
+ (parse-comparison s))
 
 ;; parse expressions or blocks introduced by syntactic reserved words
 (define (parse-resword s word)
@@ -1399,14 +1400,20 @@
 
 ;; as above, but allows both "i=r" and "i in r"
 (define (parse-iteration-spec s)
- (let ((r (parse-eq* s)))
- (cond ((and (pair? r) (eq? (car r) '=)) r)
- ((eq? r ':) r)
- ((and (length= r 4) (eq? (car r) 'comparison)
- (or (eq? (caddr r) 'in) (eq? (caddr r) '∈)))
- `(= ,(cadr r) ,(cadddr r)))
- (else
- (error "invalid iteration specification")))))
+ (let* ((lhs (parse-pipes s))
+ (t (peek-token s)))
+ (cond ((memq t '(= in ∈))
+ (take-token s)
+ (let* ((rhs (parse-pipes s))
+ (t (peek-token s)))
+ #;(if (not (or (closing-token? t) (newline? t)))
+ ;; should be: (error "invalid iteration specification")
+ (syntax-deprecation s (string "for " (deparse `(= ,lhs ,rhs)) " " t)
+ (string "for " (deparse `(= ,lhs ,rhs)) "; " t)))
+ `(= ,lhs ,rhs)))
+ ((and (eq? lhs ':) (closing-token? t))
+ ':)
+ (else (error "invalid iteration specification")))))
 
 (define (parse-comma-separated-iters s)
  (let loop ((ranges '()))

src/julia-syntax.scm

@@ -1484,6 +1484,10 @@
  `(call (top next) ,coll ,state))
  ,body))))))))
 
+;; convert an operator parsed as (op a b) to (call op a b)
+(define (syntactic-op-to-call e)
+ `(call ,(car e) ,(expand-forms (cadr e)) ,(expand-forms (caddr e))))
+
 ;; table mapping expression head to a function expanding that form
 (define expand-table
  (table
@@ -1520,9 +1524,8 @@
  (lambda (e)
  `(call (top getfield) ,(expand-forms (cadr e)) ,(expand-forms (caddr e))))
 
- 'in
- (lambda (e)
- `(call in ,(expand-forms (cadr e)) ,(expand-forms (caddr e))))
+ '|<:| syntactic-op-to-call
+ '|>:| syntactic-op-to-call
 
  'const expand-const-decl
  'local expand-local-or-global-decl

test/parse.jl

@@ -22,9 +22,9 @@ let
  ("5.≥x", "5.>=x"),
  ("5.≤x", "5.<=x")]
  ex1 = parse(ex1); ex2 = parse(ex2)
- @test ex1.head === :comparison && (ex1.head === ex2.head)
- @test ex1.args[1] === 5 && ex2.args[1] === 5
- @test is(eval(Main, ex1.args[2]), eval(Main, ex2.args[2]))
+ @test ex1.head === :call && (ex1.head === ex2.head)
+ @test ex1.args[2] === 5 && ex2.args[2] === 5
+ @test is(eval(Main, ex1.args[1]), eval(Main, ex2.args[1]))
  @test ex1.args[3] === :x && (ex1.args[3] === ex2.args[3])
  end
 end
@@ -291,7 +291,7 @@ for T in (UInt8,UInt16,UInt32,UInt64)
  @test_throws OverflowError parse(T,string(big(typemax(T))+1))
 end
 
-@test parse("1 == 2|>3") == Expr(:comparison, 1, :(==), Expr(:call, :(|>), 2, 3))
+@test parse("1 == 2|>3") == Expr(:call, :(==), 1, Expr(:call, :(|>), 2, 3))
 
 # issue #12501 and pr #12502
 parse("""
@@ -365,3 +365,9 @@ let a⊂b = reduce(&, x ∈ b for x in a) && length(b)>length(a)
  @test !([1,2] ⊂ [1,3,4])
  @test !([1,2] ⊂ [1,2])
 end
+
+# issue #9503
+@test parse("x<:y") == Expr(:(<:), :x, :y)
+@test parse("x>:y") == Expr(:(>:), :x, :y)
+@test parse("x<:y<:z").head === :comparison
+@test parse("x>:y<:z").head === :comparison