ninja: no work to do.
*** Running test-arglist
===== CASE: -n -c json write () =====
json write ()
^
[ -c flag ]:1: Empty arg list not allowed
===== CASE: -n -c p (; n=42) =====
(command.Simple
blame_tok:
more_env: []
words: [{
}]
redirects: []
typed_args:
(ArgList
left:
pos_args: []
semi_tok:
named_args: [
(NamedArg
name:
value: (expr.Const c: val:(value.Int i:42))
)
]
right:
)
do_fork: T
)
===== CASE: -n -c = f(; n=42) =====
(command.Expr
keyword:
more_env: []
words: [{} {}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [(expr.Const c: val:(value.Int i:42))]
named_args: []
right:
)
do_fork: T
)
terminator:
)
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [(expr.Const c: val:(value.Int i:43))]
named_args: []
right:
)
do_fork: T
)
]
)
OK test-bug-1850
*** Running test-bug_1825_backslashes
===== CASE: -n -c echo $'trailing\
' =====
(command.Simple
blame_tok:
(Token
id: Id.Lit_Chars
col: 0
length: 4
span_id: 0
line: (SourceLine line_num:1 content:"echo $'trailing\\\n" src:(source.CFlag))
tval: echo
)
more_env: []
words: [
(CompoundWord parts:[...0x13fe])
(CompoundWord
parts: [
(SingleQuoted
left:
(Token
id: Id.Left_DollarSingleQuote
col: 5
length: 2
span_id: 2
line: ...0x1406
tval: "$'"
)
tokens: [
(Token
id: Id.Char_Literals
col: 7
length: 8
span_id: 3
line: ...0x1406
tval: trailing
)
(Token
id: Id.Unknown_Backslash
col: 15
length: 2
span_id: 4
line: ...0x1406
tval: "\\\n"
)
]
right:
(Token
id: Id.Right_SingleQuote
col: 0
length: 1
span_id: 5
line: (SourceLine line_num:2 content:"'" src:...0x3ffffffc)
tval: "'"
)
)
]
)
]
redirects: []
do_fork: T
)
===== CASE: -n -c echo $'trailing\\
' =====
(command.Simple
blame_tok:
more_env: []
words: [
{}
{
(SingleQuoted
left:
tokens: [ ]
right:
)
}
]
redirects: []
do_fork: T
)
===== CASE: -n -c echo $'trailing\
' =====
echo $'trailing\
^~
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)
===== CASE: -n -c setvar x = $'trailing\
' =====
setvar x = $'trailing\
^~
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)
OK test-bug_1825_backslashes
*** Running test-destructure
===== CASE: -n -c
func f() {
const x, y = 3, 4
#setvar x = 5
setvar y = 6
} =====
const x, y = 3, 4
^~~~~
[ -c flag ]:3: const can't be inside proc or func. Use var instead.
===== CASE: -n -c
func f() {
var x, y = 3, 4
var y = 6
} =====
var y = 6
^
[ -c flag ]:5: 'y' was already declared
===== CASE: -n -c
func f() {
var x, y = 3, 4
const y = 6
} =====
const y = 6
^~~~~
[ -c flag ]:5: const can't be inside proc or func. Use var instead.
OK test-destructure
*** Running test-eggex-capture
===== CASE: -n -c = / d+ / =====
(command.Expr
keyword: / =====
(command.Expr
keyword: / =====
(command.Expr
keyword:
e:
(Eggex
left:
regex: (re.Repeat child:(PerlClass name:d) op:(re_repeat.Op op:))
flags: [(EggexFlag negated:F flag:)]
canonical_flags: i
)
)
===== CASE: -n -c = / d+ ; !i / =====
= / d+ ; !i /
^
[ -c flag ]:1: Flag can't be negated
===== CASE: -n -c = / d+ ; reg_oops / =====
= / d+ ; reg_oops /
^~~~~~~~
[ -c flag ]:1: Invalid regex flag 'reg_oops'
===== CASE: -n -c = / d+ ; !i; PCRE / =====
(command.Expr
keyword:
e:
(Eggex
left:
regex: (re.Repeat child:(PerlClass name:d) op:(re_repeat.Op op:))
flags: [(EggexFlag negated:F flag:)]
trans_pref:
)
)
===== CASE: -n -c = / d+ ; i reg_newline ; ERE / =====
(command.Expr
keyword:
e:
(Eggex
left:
regex: (re.Repeat child:(PerlClass name:d) op:(re_repeat.Op op:))
flags: []
trans_pref:
canonical_flags: ""
)
)
===== CASE: -n -c = / d+ ; / =====
(command.Expr
keyword: trim() =====
(command.VarDecl
keyword:
lhs: [(NameType left: name:x)]
rhs:
(expr.FuncCall
func:
(Attribute
obj: (expr.Var left: name:s)
op: ">
attr:
attr_name: trim
ctx: expr_context.Store
)
args: (ArgList left: pos_args:[] named_args:[] right:)
)
)
===== CASE: -n -c func f(x Int) => List[Int] { echo hi } =====
(Func
keyword:
name:
positional:
(ParamGroup
params: [
(Param
blame_tok:
name: x
type: (TypeExpr tok: name:Int)
)
]
)
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
)
OK test-fat-arrow
*** Running test-float-literals
===== CASE: -n -c = 42.0 =====
(command.Expr
keyword:
e: (expr.Const c: val:(value.Float f:420.0))
)
===== CASE: -n -c = 42_.0 =====
= 42_.0
^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_DecInt)
===== CASE: -n -c = 42. =====
= 42.
^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)
===== CASE: -n -c = .333 =====
= .333
^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_Dot)
===== CASE: -n -c = _42.0 =====
= _42.0
^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_DecInt)
OK test-float-literals
*** Running test-for-parse-bare-word
===== CASE: -n -c
for x in bare {
echo $x
}
=====
for x in bare {
^~~~
[ -c flag ]:2: Surround this word with either parens or quotes (parse_bare_word)
===== CASE: -n -c
for x in a b {
echo $x
}
=====
(command.ForEach
keyword:
iter_names: [x]
iterable: (for_iter.Words words:[{} {}])
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {(N Id.VSub_DollarName x)}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
redirects: []
)
===== CASE: -n -c
for x in *.py {
echo $x
}
=====
(command.ForEach
keyword:
iter_names: [x]
iterable: (for_iter.Words words:[{ <.py>}])
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {(N Id.VSub_DollarName x)}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
redirects: []
)
===== CASE: -n -c
for x in "quoted" {
echo $x
}
=====
(command.ForEach
keyword:
iter_names: [x]
iterable: (for_iter.Words words:[{(DQ )}])
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {(N Id.VSub_DollarName x)}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
redirects: []
)
OK test-for-parse-bare-word
*** Running test-func-def
===== CASE: -n -c func f(p) { var p = foo } =====
func f(p) { var p = foo }
^
[ -c flag ]:1: 'p' was already declared
===== CASE: -n -c func f(p; n) { var n = foo } =====
func f(p; n) { var n = foo }
^
[ -c flag ]:1: 'n' was already declared
OK test-func-def
*** Running test-func-sig
===== CASE: -n -c func f { echo hi } =====
func f { echo hi }
^
[ -c flag ]:1: Syntax error in expression (near Id.Op_LBrace)
===== CASE: -n -c func f () { echo hi } =====
(Func
keyword:
name:
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
)
===== CASE: -n -c func f (a List[Int] = [3,4]) { echo hi } =====
(Func
keyword:
name:
positional:
(ParamGroup
params: [
(Param
blame_tok:
name: a
type:
(TypeExpr
tok:
name: List
params: [(TypeExpr tok: name:Int)]
)
default_val:
(expr.List
left:
elts: [
(expr.Const c: val:(value.Int i:3))
(expr.Const c: val:(value.Int i:4))
]
ctx: expr_context.Store
)
)
]
)
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
)
===== CASE: -n -c func f (a, b, ...rest; c) { echo hi } =====
(Func
keyword:
name:
positional:
(ParamGroup
params: [(Param blame_tok: name:a) (Param blame_tok: name:b)]
rest_of: (RestParam blame_tok: name:rest)
)
named: (ParamGroup params:[(Param blame_tok: name:c)])
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
)
===== CASE: -n -c func f (a, b, ...rest; c, ...named) { echo hi } =====
(Func
keyword:
name:
positional:
(ParamGroup
params: [(Param blame_tok: name:a) (Param blame_tok: name:b)]
rest_of: (RestParam blame_tok: name:rest)
)
named:
(ParamGroup
params: [(Param blame_tok: name:c)]
rest_of: (RestParam blame_tok: name:named)
)
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
)
===== CASE: -n -c func f (a, b, ...rest; c, ...named;) { echo hi } =====
func f (a, b, ...rest; c, ...named;) { echo hi }
^
[ -c flag ]:1: Syntax error in expression (near Id.Op_Semi)
OK test-func-sig
*** Running test-func-var-checker
===== CASE: -n -c
func f(x) {
setvar x = true
}
=====
(Func
keyword:
name:
positional: (ParamGroup params:[(Param blame_tok: name:x)])
body:
(BraceGroup
left:
children: [
(command.Mutation
keyword:
lhs: [(N Id.Expr_Name x)]
op:
rhs: (expr.Const c: val:(value.Bool b:T))
)
]
redirects: []
right:
)
)
===== CASE: -n -c
func f() {
setvar x = true
}
=====
setvar x = true
^
[ -c flag ]:3: setvar couldn't find matching 'var x' (OILS-ERR-10)
OK test-func-var-checker
*** Running test-hay-assign
===== CASE: -n -c
name = val
=====
name = val
^
[ -c flag ]:2: Unexpected = (Hint: use var/setvar, or quote it)
===== CASE: -n -c
rule {
x = 42
}
=====
x = 42
^
[ -c flag ]:3: Unexpected = (Hint: use var/setvar, or quote it)
===== CASE: -n -c
RULE {
x = 42
}
=====
x = 42
^
[ -c flag ]:3: Unexpected = (Hint: use var/setvar, or quote it)
===== CASE: -n -c
Rule {
x = 42
}
=====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
block:
(LiteralBlock
brace_group:
(BraceGroup
left:
children: [
(command.VarDecl
lhs: [(NameType left: name:x)]
rhs: (expr.Const c: val:(value.Int i:42))
)
]
redirects: []
right:
)
lines: [
(SourceLine line_num:2 content:"Rule {\n" src:(source__CFlag))
(SourceLine line_num:3 content:" x = 42\n" src:...0x7f787ae87c50)
(SourceLine line_num:4 content:"}\n" src:...0x7f787ae87c50)
]
)
do_fork: T
)
===== CASE: -n -c
Rule X Y {
x = 42
}
=====
(command.Simple
blame_tok:
more_env: []
words: [{} {} {}]
redirects: []
block:
(LiteralBlock
brace_group:
(BraceGroup
left:
children: [
(command.VarDecl
lhs: [(NameType left: name:x)]
rhs: (expr.Const c: val:(value.Int i:42))
)
]
redirects: []
right:
)
lines: [
(SourceLine line_num:2 content:"Rule X Y {\n" src:(source__CFlag))
(SourceLine line_num:3 content:" x = 42\n" src:...0x7fc263593c90)
(SourceLine line_num:4 content:"}\n" src:...0x7fc263593c90)
]
)
do_fork: T
)
===== CASE: -n -c
RULe { # inconsistent but OK
x = 42
}
=====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
block:
(LiteralBlock
brace_group:
(BraceGroup
left:
children: [
(command.VarDecl
lhs: [(NameType left: name:x)]
rhs: (expr.Const c: val:(value.Int i:42))
)
]
redirects: []
right:
)
lines: [
(SourceLine line_num:2 content:"RULe { # inconsistent but OK\n" src:(source__CFlag))
(SourceLine line_num:3 content:" x = 42\n" src:...0x7fb6deed7c50)
(SourceLine line_num:4 content:"}\n" src:...0x7fb6deed7c50)
]
)
do_fork: T
)
===== CASE: -n -c
hay eval :result {
Rule {
foo = 42
}
bar = 43 # parse error here
}
=====
bar = 43 # parse error here
^
[ -c flag ]:8: Unexpected = (Hint: use var/setvar, or quote it)
===== CASE: -n -c
hay define TASK
TASK build {
foo = 42
}
=====
foo = 42
^
[ -c flag ]:5: Unexpected = (Hint: use var/setvar, or quote it)
===== CASE: -n -c
hay define Package/TASK
Package libc {
TASK build {
# this is not an attribute, should not be valid
foo = 42
}
}
=====
foo = 42
^
[ -c flag ]:7: Unexpected = (Hint: use var/setvar, or quote it)
===== CASE: -n -c
hay define Rule
Rule {
return (x)
}
=====
return (x)
^
[ -c flag ]:5: Typed return is only allowed inside func
OK test-hay-assign
*** Running test-hay-shell-assign
===== CASE: -n -c
hay define Package
Package foo {
version=1
}
=====
version=1
^~~~~~~~
[ -c flag ]:5: Use var/setvar to assign in YSH
===== CASE: -n -c
hay define Package/User
Package foo {
User bob {
sudo=1
}
}
=====
sudo=1
^~~~~
[ -c flag ]:6: Use var/setvar to assign in YSH
===== CASE: -n -c
hay define Package/SHELL/User
Package foo {
SHELL bob {
sudo=1
User {
name = "z"
}
}
}
=====
(command.CommandList
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {} { }]
redirects: []
do_fork: T
)
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
block:
(LiteralBlock
brace_group:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
block:
(LiteralBlock
brace_group:
(BraceGroup
left:
children: [
(command.ShAssignment
left:
children: [
(command.VarDecl
lhs: [(NameType left: name:name)]
rhs: (DQ )
)
]
redirects: []
right:
)
lines: [
(SourceLine
line_num: 7
content: " User {\n"
src: (source__CFlag)
)
(SourceLine
line_num: 8
content: " name = \"z\"\n"
src: ...0x7ff0c05fdc50
)
(SourceLine
line_num: 9
content: " }\n"
src: ...0x7ff0c05fdc50
)
]
)
do_fork: T
)
]
redirects: []
right:
)
lines: []
)
do_fork: T
)
]
redirects: []
right:
)
lines: []
)
do_fork: T
)
]
)
===== CASE: -n -c
hay define Package/SHELL/User
Package foo {
SHELL bob {
# Disallowed
# a = b
User {
x=1
}
}
}
=====
x=1
^~
[ -c flag ]:9: Use var/setvar to assign in YSH
OK test-hay-shell-assign
*** Running test-int-literals
===== CASE: -n -c = 42 =====
(command.Expr keyword: e:(expr.Const c: val:(value.Int i:420)))
===== CASE: -n -c = 42_ =====
= 42_
^
[ -c flag ]:1: Units suffix not implemented
===== CASE: -n -c = 42_0_ =====
= 42_0_
^
[ -c flag ]:1: Units suffix not implemented
===== CASE: -n -c = _42 =====
(command.Expr keyword:
child:
(expr.FuncCall
func: (expr.Var left: name:sorted)
args:
(ArgList
left:
pos_args: [(expr.Var left: name:x)]
named_args: []
right:
)
)
right:
)
}
]
redirects: []
do_fork: T
)
===== CASE: -n -c
f() {
write -- @[sorted(x)]
}
=====
write -- @[sorted(x)]
^
[ -c flag ]:3: Unexpected left paren (might need a space before it)
===== CASE: -n -c
f() {
write -- @[sorted(x)]
}
=====
(command.ShFunction
name_tok:
name: f
body:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [
{}
{<-->}
{
(word_part.ExprSub
left:
child:
(expr.FuncCall
func: (expr.Var left: name:sorted)
args:
(ArgList
left:
pos_args: [(expr.Var left: name:x)]
named_args: []
right:
)
)
right:
)
}
]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
)
===== CASE: -n -c
f() {
write -- @sorted (( z ))
}
=====
write -- @sorted (( z ))
^~
[ -c flag ]:3: Invalid word while parsing command list
OK test-invalid_parens
*** Running test-lazy-arg-list
===== CASE: -n -c assert [42 === x] =====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [
(expr.Compare
left: (expr.Const c: val:(value.Int i:42))
ops: []
comparators: [(expr.Var left: name:x)]
)
]
named_args: []
right:
)
do_fork: T
)
===== CASE: -n -c assert [ 42 === x ] =====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [
(expr.Compare
left: (expr.Const c: val:(value.Int i:42))
ops: []
comparators: [(expr.Var left: name:x)]
)
]
named_args: []
right:
)
do_fork: T
)
===== CASE: -n -c assert [42, 43] =====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [
(expr.Const c: val:(value.Int i:42))
(expr.Const c: val:(value.Int i:43))
]
named_args: []
right:
)
do_fork: T
)
===== CASE: -n -c assert [42, named=true] =====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [(expr.Const c: val:(value.Int i:42))]
named_args: [
(NamedArg
name:
value: (expr.Const c: val:(value.Bool b:T))
)
]
right:
)
do_fork: T
)
===== CASE: -n -c assert [42, named=true]; echo hi =====
(command.CommandList
children: [
(command.Sentence
child:
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [(expr.Const c: val:(value.Int i:42))]
named_args: [
(NamedArg
name:
value: (expr.Const c: val:(value.Bool b:T))
)
]
right:
)
do_fork: T
)
terminator:
)
(command.Simple blame_tok: more_env:[] words:[{} {}] redirects:[] do_fork:T)
]
)
===== CASE: -n -c assert [42, named=true] { echo hi } =====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [(expr.Const c: val:(value.Int i:42))]
named_args: [
(NamedArg
name:
value: (expr.Const c: val:(value.Bool b:T))
)
]
right:
)
block:
(LiteralBlock
brace_group:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
lines: [(SourceLine line_num:1 content:"assert [42, named=true] { echo hi }" src:(source__CFlag))]
)
do_fork: T
)
===== CASE: -n -c assert [42, named=true]{ echo hi } =====
(command.Simple
blame_tok:
more_env: []
words: [{}]
redirects: []
typed_args:
(ArgList
left:
pos_args: [(expr.Const c: val:(value.Int i:42))]
named_args: [
(NamedArg
name:
value: (expr.Const c: val:(value.Bool b:T))
)
]
right:
)
block:
(LiteralBlock
brace_group:
(BraceGroup
left:
children: [
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: []
do_fork: T
)
]
redirects: []
right:
)
lines: [(SourceLine line_num:1 content:"assert [42, named=true]{ echo hi }" src:(source__CFlag))]
)
do_fork: T
)
===== CASE: -n -c assert *.[ch] =====
(command.Simple
blame_tok:
more_env: []
words: [{