*** 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:))]
right:
)
do_fork: T
)
===== CASE: -n -c = f(; n=42) =====
(command.Expr
keyword:
e:
(Eggex
left:
regex: (re.Repeat child:(PerlClass name:d) op:(re_repeat.Op op:))
flags: []
canonical_flags: ""
)
)
===== CASE: -n -c = / < capture d+ as date > / =====
(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 name:)]
rhs:
(expr.FuncCall
func:
(Attribute
obj: (expr.Var name:)
op: ">
attr:
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:))
===== 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: [{} {($ 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: [{} {($ 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: [{} {($ 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:) (expr.Const c:)]
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: [(y_lhs.Var name:)]
op:
rhs: (expr.Var name:)
)
]
redirects: []
right:
)
)
===== CASE: -n -c
func f() {
setvar x = True
}
=====
setvar x = True
^
[ -c flag ]:3: setvar couldn't find matching 'var x'
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 name:)] rhs:(expr.Const c:))]
redirects: []
right:
)
lines: [
(SourceLine line_num:2 content:"Rule {\n" src:(source__CFlag))
(SourceLine line_num:3 content:" x = 42\n" src:...0x7f58a2e30f50)
(SourceLine line_num:4 content:"}\n" src:...0x7f58a2e30f50)
]
)
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 name:)] rhs:(expr.Const c:))]
redirects: []
right:
)
lines: [
(SourceLine line_num:2 content:"Rule X Y {\n" src:(source__CFlag))
(SourceLine line_num:3 content:" x = 42\n" src:...0x7ff17824ef50)
(SourceLine line_num:4 content:"}\n" src:...0x7ff17824ef50)
]
)
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 name:)] rhs:(expr.Const c:))]
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:...0x7fa764713f10)
(SourceLine line_num:4 content:"}\n" src:...0x7fa764713f10)
]
)
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 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: ...0x7f364287ef10
)
(SourceLine
line_num: 9
content: " }\n"
src: ...0x7f364287ef10
)
]
)
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:))
===== 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:
pos_args: [
(expr.Compare
left: (expr.Const c:)
ops: []
comparators: [(expr.Var name:)]
)
]
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:)
ops: []
comparators: [(expr.Var name:)]
)
]
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:) (expr.Const c:)]
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:)]
named_args: [(NamedArg name: value:(expr.Const c:))]
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:)]
named_args: [
(NamedArg
name:
value: (expr.Const c:)
)
]
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:)]
named_args: [(NamedArg name: value:(expr.Const c:))]
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:)]
named_args: [(NamedArg name: value:(expr.Const c:))]
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: [{} { <.> }]
redirects: []
do_fork: T
)
===== CASE: -n -c assert 42[ch] =====
(command.Simple
blame_tok:
more_env: []
words: [{} {<42> }]
redirects: []
do_fork: T
)
===== CASE: -n -c echo[] =====
(command.Simple
blame_tok:
more_env: []
words: [{ }]
redirects: []
do_fork: T
)
===== CASE: -n -c assert [4 =====
assert [4
^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)
===== CASE: -n -c assert [ 4 =====
assert [ 4
^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)
===== CASE: -n -c json write (42) >out =====
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: [(Redir op:"> loc:(redir_loc.Fd fd:1) arg:{})]
typed_args:
(ArgList
left:
pos_args: [(expr.Const c:)]
named_args: []
right:
)
do_fork: T
)
===== CASE: -n -c json write >out (42) =====
(command.Simple
blame_tok:
more_env: []
words: [{} {}]
redirects: [(Redir op:"> loc:(redir_loc.Fd fd:1) arg:{})]
typed_args:
(ArgList
left:
pos_args: [(expr.Const c:)]
named_args: []
right:
)
do_fork: T
)
===== CASE: -n -c [ x = y ] =====
(command.Simple
blame_tok:
more_env: []
words: [{} {} {}]
redirects: []
do_fork: T
)
OK test-lazy-arg-list
*** Running test-make-these-nicer
===== CASE: -n -c = =====
=
^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)
===== CASE: -n -c call =====
call
^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)
===== CASE: -n -c const d = { name:
42 } =====
const d = { name:
^
[ -c flag ]:1: Syntax error in expression (near Id.Op_Newline)
OK test-make-these-nicer
*** Running test-multiline-string
===== CASE: -n -c echo u'''
hi
'''
=====
(command.Simple
blame_tok:
more_env: []
words: [
{}
{
(SingleQuoted
left:
tokens: []
right:
)
}
]
redirects: []
do_fork: T
)
===== CASE: -n -c echo b'''
hi
'''
=====
(command.Simple
blame_tok: