s,splatarg,restarg,.

whitequark · whitequark · commit 426eb7e1144d · 2013-04-17T18:30:28.000+04:00
diff --git a/AST_FORMAT.md b/AST_FORMAT.md
@@ -718,7 +718,7 @@ Format:
 
 Format:
 ```
-(splatarg :foo)
+(restarg :foo)
 "*foo"
  ~~~~ expression
   ~~~ name
@@ -730,7 +730,7 @@ Begin of the `expression` points to `*`.
 
 Format:
 ```
-(splatarg)
+(restarg)
 "*"
  ^ expression
 ```
@@ -761,7 +761,7 @@ Format:
 (args (arg_expr (send (send nil :foo) :a=)))
 "|foo.a|"
 
-(args (splatarg_expr (ivasgn :@bar)))
+(args (restarg_expr (ivasgn :@bar)))
 "|*@bar|"
 
 (args (blockarg_expr (ivasgn :@bar)))
@@ -780,7 +780,7 @@ Format:
 
 Format:
 ```
-(def :f (args (arg :a) (mlhs (arg :foo) (splatarg :bar))))
+(def :f (args (arg :a) (mlhs (arg :foo) (restarg :bar))))
 "def f(a, (foo, *bar)); end"
           ^ begin   ^ end
           ~~~~~~~~~~~ expression
@@ -810,7 +810,7 @@ Format:
 
 Format:
 ```
-(kwsplatarg :foo)
+(kwrestarg :foo)
 "**foo"
  ~~~~~ expression
    ~~~ name
@@ -820,7 +820,7 @@ Format:
 
 Format:
 ```
-(kwsplatarg)
+(kwrestarg)
 "**"
  ~~ expression
 ```
diff --git a/lib/parser/builders/default.rb b/lib/parser/builders/default.rb
@@ -404,11 +404,11 @@ def optarg(token, eql_t, value)
       s(:optarg, value(token).to_sym, value)
     end
 
-    def splatarg(star_t, token=nil)
+    def restarg(star_t, token=nil)
       if token
-        s(:splatarg, value(token).to_sym)
+        s(:restarg, value(token).to_sym)
       else
-        t(star_t, :splatarg)
+        t(star_t, :restarg)
       end
     end
 
@@ -430,13 +430,13 @@ def arg_expr(expr)
       end
     end
 
-    def splatarg_expr(star_t, expr=nil)
+    def restarg_expr(star_t, expr=nil)
       if expr.nil?
-        t(star_t, :splatarg)
+        t(star_t, :restarg)
       elsif expr.type == :lvasgn
-        expr.updated(:splatarg)
+        expr.updated(:restarg)
       else
-        s(:splatarg_expr, expr)
+        s(:restarg_expr, expr)
       end
     end
 
diff --git a/lib/parser/ruby18.y b/lib/parser/ruby18.y
@@ -1294,42 +1294,42 @@ rule
                 | block_par tCOMMA tSTAR lhs tCOMMA tAMPER lhs
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2], val[3])).
+                                  push(@builder.restarg_expr(val[2], val[3])).
                                   push(@builder.blockarg_expr(val[5], val[6]))
                     }
                 | block_par tCOMMA tSTAR tCOMMA tAMPER lhs
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2])).
+                                  push(@builder.restarg_expr(val[2])).
                                   push(@builder.blockarg_expr(val[4], val[5]))
                     }
                 | block_par tCOMMA tSTAR lhs
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2], val[3]))
+                                  push(@builder.restarg_expr(val[2], val[3]))
                     }
                 | block_par tCOMMA tSTAR
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2]))
+                                  push(@builder.restarg_expr(val[2]))
                     }
                 | tSTAR lhs tCOMMA tAMPER lhs
                     {
-                      result =  [ @builder.splatarg_expr(val[0], val[1]),
+                      result =  [ @builder.restarg_expr(val[0], val[1]),
                                   @builder.blockarg_expr(val[3], val[4]) ]
                     }
                 | tSTAR tCOMMA tAMPER lhs
                     {
-                      result =  [ @builder.splatarg_expr(val[0]),
+                      result =  [ @builder.restarg_expr(val[0]),
                                   @builder.blockarg_expr(val[2], val[3]) ]
                     }
                 | tSTAR lhs
                     {
-                      result =  [ @builder.splatarg_expr(val[0], val[1]) ]
+                      result =  [ @builder.restarg_expr(val[0], val[1]) ]
                     }
                 | tSTAR
                     {
-                      result =  [ @builder.splatarg_expr(val[0]) ]
+                      result =  [ @builder.restarg_expr(val[0]) ]
                     }
                 | tAMPER lhs
                     {
@@ -1850,11 +1850,11 @@ xstring_contents: # nothing
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 | restarg_mark
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
 
      blkarg_mark: tAMPER2 | tAMPER
diff --git a/lib/parser/ruby19.y b/lib/parser/ruby19.y
@@ -1260,47 +1260,47 @@ rule
                       @static_env.declare val[3][0]
 
                       result = val[0].
-                                  push(@builder.splatarg(val[2], val[3]))
+                                  push(@builder.restarg(val[2], val[3]))
                     }
                 | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
                     {
                       @static_env.declare val[3][0]
 
                       result = val[0].
-                                  push(@builder.splatarg(val[2], val[3])).
+                                  push(@builder.restarg(val[2], val[3])).
                                   concat(val[5])
                     }
                 | f_marg_list tCOMMA tSTAR
                     {
                       result = val[0].
-                                  push(@builder.splatarg(val[2]))
+                                  push(@builder.restarg(val[2]))
                     }
                 | f_marg_list tCOMMA tSTAR            tCOMMA f_marg_list
                     {
                       result = val[0].
-                                  push(@builder.splatarg(val[2])).
+                                  push(@builder.restarg(val[2])).
                                   concat(val[4])
                     }
                 |                    tSTAR f_norm_arg
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 |                    tSTAR f_norm_arg tCOMMA f_marg_list
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]),
+                      result = [ @builder.restarg(val[0], val[1]),
                                  *val[3] ]
                     }
                 |                    tSTAR
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
                 |                    tSTAR tCOMMA f_marg_list
                     {
-                      result = [ @builder.splatarg(val[0]),
+                      result = [ @builder.restarg(val[0]),
                                  *val[2] ]
                     }
 
@@ -2046,11 +2046,11 @@ keyword_variable: kNIL
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 | restarg_mark
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
 
      blkarg_mark: tAMPER2 | tAMPER
diff --git a/lib/parser/ruby20.y b/lib/parser/ruby20.y
@@ -1285,47 +1285,47 @@ rule
                       @static_env.declare val[3][0]
 
                       result = val[0].
-                                  push(@builder.splatarg(val[2], val[3]))
+                                  push(@builder.restarg(val[2], val[3]))
                     }
                 | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
                     {
                       @static_env.declare val[3][0]
 
                       result = val[0].
-                                  push(@builder.splatarg(val[2], val[3])).
+                                  push(@builder.restarg(val[2], val[3])).
                                   concat(val[5])
                     }
                 | f_marg_list tCOMMA tSTAR
                     {
                       result = val[0].
-                                  push(@builder.splatarg(val[2]))
+                                  push(@builder.restarg(val[2]))
                     }
                 | f_marg_list tCOMMA tSTAR            tCOMMA f_marg_list
                     {
                       result = val[0].
-                                  push(@builder.splatarg(val[2])).
+                                  push(@builder.restarg(val[2])).
                                   concat(val[4])
                     }
                 |                    tSTAR f_norm_arg
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 |                    tSTAR f_norm_arg tCOMMA f_marg_list
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]),
+                      result = [ @builder.restarg(val[0], val[1]),
                                  *val[3] ]
                     }
                 |                    tSTAR
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
                 |                    tSTAR tCOMMA f_marg_list
                     {
-                      result = [ @builder.splatarg(val[0]),
+                      result = [ @builder.restarg(val[0]),
                                  *val[2] ]
                     }
 
@@ -2097,11 +2097,11 @@ keyword_variable: kNIL
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 | restarg_mark
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
 
      blkarg_mark: tAMPER2 | tAMPER
diff --git a/test/test_parser.rb b/test/test_parser.rb

Original file line number	Diff line number	Diff line change
`@@ -1294,42 +1294,42 @@ rule`
`1294`	`1294`	`\| block_par tCOMMA tSTAR lhs tCOMMA tAMPER lhs`
`1295`	`1295`	`{`
`1296`	`1296`	`result = val[0].`
`1297`		`- push(@builder.splatarg_expr(val[2], val[3])).`
	`1297`	`+ push(@builder.restarg_expr(val[2], val[3])).`
`1298`	`1298`	`push(@builder.blockarg_expr(val[5], val[6]))`
`1299`	`1299`	`}`
`1300`	`1300`	`\| block_par tCOMMA tSTAR tCOMMA tAMPER lhs`
`1301`	`1301`	`{`
`1302`	`1302`	`result = val[0].`
`1303`		`- push(@builder.splatarg_expr(val[2])).`
	`1303`	`+ push(@builder.restarg_expr(val[2])).`
`1304`	`1304`	`push(@builder.blockarg_expr(val[4], val[5]))`
`1305`	`1305`	`}`
`1306`	`1306`	`\| block_par tCOMMA tSTAR lhs`
`1307`	`1307`	`{`
`1308`	`1308`	`result = val[0].`
`1309`		`- push(@builder.splatarg_expr(val[2], val[3]))`
	`1309`	`+ push(@builder.restarg_expr(val[2], val[3]))`
`1310`	`1310`	`}`
`1311`	`1311`	`\| block_par tCOMMA tSTAR`
`1312`	`1312`	`{`
`1313`	`1313`	`result = val[0].`
`1314`		`- push(@builder.splatarg_expr(val[2]))`
	`1314`	`+ push(@builder.restarg_expr(val[2]))`
`1315`	`1315`	`}`
`1316`	`1316`	`\| tSTAR lhs tCOMMA tAMPER lhs`
`1317`	`1317`	`{`
`1318`		`- result = [ @builder.splatarg_expr(val[0], val[1]),`
	`1318`	`+ result = [ @builder.restarg_expr(val[0], val[1]),`
`1319`	`1319`	`@builder.blockarg_expr(val[3], val[4]) ]`
`1320`	`1320`	`}`
`1321`	`1321`	`\| tSTAR tCOMMA tAMPER lhs`
`1322`	`1322`	`{`
`1323`		`- result = [ @builder.splatarg_expr(val[0]),`
	`1323`	`+ result = [ @builder.restarg_expr(val[0]),`
`1324`	`1324`	`@builder.blockarg_expr(val[2], val[3]) ]`
`1325`	`1325`	`}`
`1326`	`1326`	`\| tSTAR lhs`
`1327`	`1327`	`{`
`1328`		`- result = [ @builder.splatarg_expr(val[0], val[1]) ]`
	`1328`	`+ result = [ @builder.restarg_expr(val[0], val[1]) ]`
`1329`	`1329`	`}`
`1330`	`1330`	`\| tSTAR`
`1331`	`1331`	`{`
`1332`		`- result = [ @builder.splatarg_expr(val[0]) ]`
	`1332`	`+ result = [ @builder.restarg_expr(val[0]) ]`
`1333`	`1333`	`}`
`1334`	`1334`	`\| tAMPER lhs`
`1335`	`1335`	`{`
`@@ -1850,11 +1850,11 @@ xstring_contents: # nothing`
`1850`	`1850`	`{`
`1851`	`1851`	`@static_env.declare val[1][0]`
`1852`	`1852`
`1853`		`- result = [ @builder.splatarg(val[0], val[1]) ]`
	`1853`	`+ result = [ @builder.restarg(val[0], val[1]) ]`
`1854`	`1854`	`}`
`1855`	`1855`	`\| restarg_mark`
`1856`	`1856`	`{`
`1857`		`- result = [ @builder.splatarg(val[0]) ]`
	`1857`	`+ result = [ @builder.restarg(val[0]) ]`
`1858`	`1858`	`}`
`1859`	`1859`
`1860`	`1860`	`blkarg_mark: tAMPER2 \| tAMPER`
Original file line number	Diff line number	Diff line change
`@@ -1260,47 +1260,47 @@ rule`
`1260`	`1260`	`@static_env.declare val[3][0]`
`1261`	`1261`
`1262`	`1262`	`result = val[0].`
`1263`		`- push(@builder.splatarg(val[2], val[3]))`
	`1263`	`+ push(@builder.restarg(val[2], val[3]))`
`1264`	`1264`	`}`
`1265`	`1265`	`\| f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list`
`1266`	`1266`	`{`
`1267`	`1267`	`@static_env.declare val[3][0]`
`1268`	`1268`
`1269`	`1269`	`result = val[0].`
`1270`		`- push(@builder.splatarg(val[2], val[3])).`
	`1270`	`+ push(@builder.restarg(val[2], val[3])).`
`1271`	`1271`	`concat(val[5])`
`1272`	`1272`	`}`
`1273`	`1273`	`\| f_marg_list tCOMMA tSTAR`
`1274`	`1274`	`{`
`1275`	`1275`	`result = val[0].`
`1276`		`- push(@builder.splatarg(val[2]))`
	`1276`	`+ push(@builder.restarg(val[2]))`
`1277`	`1277`	`}`
`1278`	`1278`	`\| f_marg_list tCOMMA tSTAR tCOMMA f_marg_list`
`1279`	`1279`	`{`
`1280`	`1280`	`result = val[0].`
`1281`		`- push(@builder.splatarg(val[2])).`
	`1281`	`+ push(@builder.restarg(val[2])).`
`1282`	`1282`	`concat(val[4])`
`1283`	`1283`	`}`
`1284`	`1284`	`\| tSTAR f_norm_arg`
`1285`	`1285`	`{`
`1286`	`1286`	`@static_env.declare val[1][0]`
`1287`	`1287`
`1288`		`- result = [ @builder.splatarg(val[0], val[1]) ]`
	`1288`	`+ result = [ @builder.restarg(val[0], val[1]) ]`
`1289`	`1289`	`}`
`1290`	`1290`	`\| tSTAR f_norm_arg tCOMMA f_marg_list`
`1291`	`1291`	`{`
`1292`	`1292`	`@static_env.declare val[1][0]`
`1293`	`1293`
`1294`		`- result = [ @builder.splatarg(val[0], val[1]),`
	`1294`	`+ result = [ @builder.restarg(val[0], val[1]),`
`1295`	`1295`	`*val[3] ]`
`1296`	`1296`	`}`
`1297`	`1297`	`\| tSTAR`
`1298`	`1298`	`{`
`1299`		`- result = [ @builder.splatarg(val[0]) ]`
	`1299`	`+ result = [ @builder.restarg(val[0]) ]`
`1300`	`1300`	`}`
`1301`	`1301`	`\| tSTAR tCOMMA f_marg_list`
`1302`	`1302`	`{`
`1303`		`- result = [ @builder.splatarg(val[0]),`
	`1303`	`+ result = [ @builder.restarg(val[0]),`
`1304`	`1304`	`*val[2] ]`
`1305`	`1305`	`}`
`1306`	`1306`
`@@ -2046,11 +2046,11 @@ keyword_variable: kNIL`
`2046`	`2046`	`{`
`2047`	`2047`	`@static_env.declare val[1][0]`
`2048`	`2048`
`2049`		`- result = [ @builder.splatarg(val[0], val[1]) ]`
	`2049`	`+ result = [ @builder.restarg(val[0], val[1]) ]`
`2050`	`2050`	`}`
`2051`	`2051`	`\| restarg_mark`
`2052`	`2052`	`{`
`2053`		`- result = [ @builder.splatarg(val[0]) ]`
	`2053`	`+ result = [ @builder.restarg(val[0]) ]`
`2054`	`2054`	`}`
`2055`	`2055`
`2056`	`2056`	`blkarg_mark: tAMPER2 \| tAMPER`
Original file line number	Diff line number	Diff line change
`@@ -1285,47 +1285,47 @@ rule`
`1285`	`1285`	`@static_env.declare val[3][0]`
`1286`	`1286`
`1287`	`1287`	`result = val[0].`
`1288`		`- push(@builder.splatarg(val[2], val[3]))`
	`1288`	`+ push(@builder.restarg(val[2], val[3]))`
`1289`	`1289`	`}`
`1290`	`1290`	`\| f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list`
`1291`	`1291`	`{`
`1292`	`1292`	`@static_env.declare val[3][0]`
`1293`	`1293`
`1294`	`1294`	`result = val[0].`
`1295`		`- push(@builder.splatarg(val[2], val[3])).`
	`1295`	`+ push(@builder.restarg(val[2], val[3])).`
`1296`	`1296`	`concat(val[5])`
`1297`	`1297`	`}`
`1298`	`1298`	`\| f_marg_list tCOMMA tSTAR`
`1299`	`1299`	`{`
`1300`	`1300`	`result = val[0].`
`1301`		`- push(@builder.splatarg(val[2]))`
	`1301`	`+ push(@builder.restarg(val[2]))`
`1302`	`1302`	`}`
`1303`	`1303`	`\| f_marg_list tCOMMA tSTAR tCOMMA f_marg_list`
`1304`	`1304`	`{`
`1305`	`1305`	`result = val[0].`
`1306`		`- push(@builder.splatarg(val[2])).`
	`1306`	`+ push(@builder.restarg(val[2])).`
`1307`	`1307`	`concat(val[4])`
`1308`	`1308`	`}`
`1309`	`1309`	`\| tSTAR f_norm_arg`
`1310`	`1310`	`{`
`1311`	`1311`	`@static_env.declare val[1][0]`
`1312`	`1312`
`1313`		`- result = [ @builder.splatarg(val[0], val[1]) ]`
	`1313`	`+ result = [ @builder.restarg(val[0], val[1]) ]`
`1314`	`1314`	`}`
`1315`	`1315`	`\| tSTAR f_norm_arg tCOMMA f_marg_list`
`1316`	`1316`	`{`
`1317`	`1317`	`@static_env.declare val[1][0]`
`1318`	`1318`
`1319`		`- result = [ @builder.splatarg(val[0], val[1]),`
	`1319`	`+ result = [ @builder.restarg(val[0], val[1]),`
`1320`	`1320`	`*val[3] ]`
`1321`	`1321`	`}`
`1322`	`1322`	`\| tSTAR`
`1323`	`1323`	`{`
`1324`		`- result = [ @builder.splatarg(val[0]) ]`
	`1324`	`+ result = [ @builder.restarg(val[0]) ]`
`1325`	`1325`	`}`
`1326`	`1326`	`\| tSTAR tCOMMA f_marg_list`
`1327`	`1327`	`{`
`1328`		`- result = [ @builder.splatarg(val[0]),`
	`1328`	`+ result = [ @builder.restarg(val[0]),`
`1329`	`1329`	`*val[2] ]`
`1330`	`1330`	`}`
`1331`	`1331`
`@@ -2097,11 +2097,11 @@ keyword_variable: kNIL`
`2097`	`2097`	`{`
`2098`	`2098`	`@static_env.declare val[1][0]`
`2099`	`2099`
`2100`		`- result = [ @builder.splatarg(val[0], val[1]) ]`
	`2100`	`+ result = [ @builder.restarg(val[0], val[1]) ]`
`2101`	`2101`	`}`
`2102`	`2102`	`\| restarg_mark`
`2103`	`2103`	`{`
`2104`		`- result = [ @builder.splatarg(val[0]) ]`
	`2104`	`+ result = [ @builder.restarg(val[0]) ]`
`2105`	`2105`	`}`
`2106`	`2106`
`2107`	`2107`	`blkarg_mark: tAMPER2 \| tAMPER`