mass replace (done by sed).
no additional semantic.
Signed-off-by: Jean Privat <jean@pryen.org>
import array
-var a: Array[nullable Int] = [1, 2, 3, null, 5]#!alt1#
+var a: Array[nullable Int] = [1, 2, 3, null, 5]#alt1#
#alt1#var a = [1, 2, 3, null, 5]
for i in a do
init do end
end
-var a = new A[nullable Int]#!alt1#
+var a = new A[nullable Int]#alt1#
#alt1#var a = new A[Int]
a.e.output
show(1)
_a1 = new Integer(1)
show(2)
- _a2 = new Integer(_a1.val + 1) #!alt3# #!alt4#
+ _a2 = new Integer(_a1.val + 1) #alt3# #alt4#
show(3)
end
#alt3#
class Bar
super Foo
- var _a3: Integer#!alt1# #!alt2#
+ var _a3: Integer#alt1# #alt2#
#alt1#var _a3: Integer = new Integer(9000)
#alt2#var _a3: nullable Integer
redef fun run
!bar
do
1.output
- bar #!alt1#
+ bar #alt1#
#alt2#bar(2)
#alt3#var x = bar
4.output
fun work
do
var a = new A
- a.foo !bar do #!alt11#
+ a.foo !bar do #alt11#
#alt11#a.foo !bar x do
2.output
if maybe then
!bar(i: Int)
do
1.output
- bar(2) #!alt1#
+ bar(2) #alt1#
#alt2#bar
#alt12#bar('x')
#alt3#var x = bar(2)
fun work
do
var a = new A
- a.foo !bar x do #!alt11#
+ a.foo !bar x do #alt11#
#alt11#a.foo !bar do
x.output
if maybe then
var a = new A
0.output
-a.foo(1,8) !bar x, y, b do #!alt2#
+a.foo(1,8) !bar x, y, b do #alt2#
#alt2#a.foo(1,8) !bar x, y do
x.output
b.foo(x+1, y-1) !bar z, t, c do
!bar: Int
do
1.output
- bar.output #!alt1#
+ bar.output #alt1#
#alt2#bar(2)
#alt3#var x: Char = bar
4.output
fun work
do
var a = new A
- a.foo !bar do #!alt11#
+ a.foo !bar do #alt11#
#alt11#a.foo !bar x do
2.output
if maybe then
#alt7#continue
#alt8#continue 'x'
end
- continue 5 #!alt9#
+ continue 5 #alt9#
end
4.output
return i
var v: V = new V
var w: W = new W
-var y: Object#!alt1#
+var y: Object#alt1#
#alt1#var y: U
y = a.foo !bar do 0.output
y = a.foo !bar do break t
class A
fun foo
- break !bar #!alt12#
+ break !bar #alt12#
#alt12#break !bar: Int
do
1.output
- if maybe then bar #!alt1#
+ if maybe then bar #alt1#
#alt2#if maybe then bar(2)
#alt3#if maybe then var x = bar
4.output
fun work
do
var a = new A
- a.foo !bar do #!alt11#
+ a.foo !bar do #alt11#
#alt11#a.foo !bar x do
2.output
if maybe then
#alt9#return 'x'
end
3.output
- break #!alt13#
+ break #alt13#
end
#alt10# a.foo
5.output
class A
fun foo: Int
- break !bar #!alt12#
+ break !bar #alt12#
#alt12#break !bar: Int
do
1.output
- if maybe then bar #!alt1#
+ if maybe then bar #alt1#
#alt2#if maybe then bar(2)
#alt3#if maybe then var x = bar
return 4
fun work
do
var a = new A
- var r = a.foo !bar do #!alt11#
+ var r = a.foo !bar do #alt11#
#alt11#var r = a.foo !bar x do
2.output
if maybe then
#alt9#return 'x'
end
3.output
- break 4 #!alt13#
+ break 4 #alt13#
end
r.output
#alt10# a.foo
#alt7# break 1
#alt8# break 'x'
end
- break 20#!alt9#
+ break 20#alt9#
end
do
1.output
#alt6# break 1
end
#alt5# break
- continue 20 #!alt5#
+ continue 20 #alt5#
end
do
1.output
#alt6# break
#alt7# break 1
end
- continue i * 10 #!alt5#
+ continue i * 10 #alt5#
end
do
1.output
import kernel
fun a
!a1
- !a2 #!alt1#
+ !a2 #alt1#
#alt2# !a3
#alt6# !a1
do
a1
- a2 #!alt1#
+ a2 #alt1#
#alt2# a3
end
a !a1 do
b !b1 do
1.output
- !b2 do #!alt3#
- 2.output #!alt3#
+ !b2 do #alt3#
+ 2.output #alt3#
#alt4# !b3 do
#alt4# 20.output
end
class B
super A
redef fun foo
- !bar(i: Int) #!alt13# #!alt14# #!alt15#
+ !bar(i: Int) #alt13# #alt14# #alt15#
#alt13# !bar
#alt14# !bar(b: Bool)
#alt15# !bar(i: Int): Int
do
10.output
- bar(20) #!alt1#
+ bar(20) #alt1#
#alt2#bar
#alt12#bar('x')
#alt3#var x = bar(2)
fun work2
do
var a: A = new B
- a.foo !bar x do #!alt11#
+ a.foo !bar x do #alt11#
#alt11#a.foo !bar do
x.output
if maybe then
import kernel
-var i = 1#!alt1#
+var i = 1#alt1#
#alt1#var i: Object = 1
i += 2
i.output
a
if true then return 0
a
- return 1#!alt1#
+ return 1#alt1#
end
fun c: Int
return 0
end
a
- return 2#!alt1#
+ return 2#alt1#
end
fun d: Int
class A
var v: Int
- fun iterate #!alt1#
+ fun iterate #alt1#
#alt1# fun foo
- !each(i: Int) #!alt2# #!alt5#
+ !each(i: Int) #alt2# #alt5#
#alt5#!each(i: Int): Int
do
each(v)
end
var a = new A(5)
-for i in a do #!alt3#
+for i in a do #alt3#
#alt3#for i, j in a do
i.output
end
var b = new B(5)
-for i, j in b do #!alt4#
+for i, j in b do #alt4#
#alt4#for i in b do
i.output
- j.output #!alt4#
+ j.output #alt4#
end
import kernel
class A
- readable var _x: Int #!alt1#
+ readable var _x: Int #alt1#
#alt1#readable var _x: Int = 2
- readable var _y: Int = -2 #!alt2#
+ readable var _y: Int = -2 #alt2#
#alt2#readable var _y: Int
#alt3#init (xx: Int) do _x = xx
#alt4#init foo(xx: Int) do _x = xx
end
var a: A
-a = new A(1)#!alt1##!alt2##!alt3##!alt4#
+a = new A(1)#alt1##alt2##alt3##alt4#
#alt1#a = new A
#alt2#a = new A(3, -3)
#alt3#a = new A(4)
'1'.output
' '.output
#alt4# init
- initb #!alt2#
+ initb #alt2#
'D'.output
'2'.output
' '.output
class B
super A
#alt1#redef init do '1'.output
- init do '1'.output #!alt1#
+ init do '1'.output #alt1#
#alt1#redef init init2 do '2'.output
- init init2 do '2'.output #!alt1#
+ init init2 do '2'.output #alt1#
#alt1#redef init init3 do '3'.output
- init init3 do '3'.output #!alt1#
+ init init3 do '3'.output #alt1#
end
(new A).foo
end
if maybe then break label l1
4.output
- end label l2#!alt6#
+ end label l2#alt6#
#alt6#end label l1
5.output
end label l1
if maybe then break label l1 10
4.output
break 4
- end label l2#!alt6#
+ end label l2#alt6#
#alt6#end label l1
j.output
5.output
4.output
!baz do
40.output
- end label l2#!alt6#
+ end label l2#alt6#
#alt6#end label l1
5.output
!baz do
end
if maybe then break label l1
4.output
- end label l2#!alt6#
+ end label l2#alt6#
#alt6#end label l1
5.output
end label l1
end
if maybe then break label l1
4.output
- end label l2#!alt6#
+ end label l2#alt6#
#alt6#end label l1
5.output
end label l1
if maybe then break label l1
4.output
if maybe then break
- end label l2#!alt6#
+ end label l2#alt6#
#alt6#end label l1
5.output
end label l1
end
if maybe then break label l1
4.output
- end label l2#!alt6#
+ end label l2#alt6#
#alt6#end label l1
5.output
end label l1
var c: Object
if maybe then
- c = 2 #!alt2# #!alt4#
+ c = 2 #alt2# #alt4#
else
- c = 2 #!alt3# #!alt4#
+ c = 2 #alt3# #alt4#
end
c.output
a = new B
else
a = new C
- abort#!alt6#
+ abort#alt6#
end
a.a
a.b
var a: nullable Object = null
a = new B
if rand then
- a = null #!alt1#
+ a = null #alt1#
#alt2#a = new A
#alt3#a = new B
end
eat_na(a)
#alt1#eat_a(a)
'\n'.output
- abort#!alt2#
+ abort#alt2#
end
eat_na(a)
eat_a(a)
eat_a(a)
break label doblock
end
- abort #!alt4#
+ abort #alt4#
end label doblock
eat_na(a)
eat_a(a)
import kernel
#alt1#class Object
-redef class Object #!alt1#
+redef class Object #alt1#
fun bar: Int do return 10 + baz
end
class A
fun foo: Int do return 100 + bar
#alt2# fun foo(c: Char) do (200 + bar).output
- redef fun bar: Int do return 20 + baz #!alt3#
+ redef fun bar: Int do return 20 + baz #alt3#
#alt3# fun bar: Int do return 30 + baz
#alt4# fun baz(c: Char) do 2.output
#alt5# redef fun baz(c: Char) do 2.output
import kernel
class A
- readable var _x: Int #!alt1#
+ readable var _x: Int #alt1#
#alt1#readable var _x: Int = 2
- readable var _y: Int = -2 #!alt2#
+ readable var _y: Int = -2 #alt2#
#alt2#readable var _y: Int
#alt3#init (xx: Int) do _x = xx
#alt4#init foo(xx: Int) do _x = xx
-import end#!alt7#
+import end#alt7#
#alt7#import kernel
-class Object#!alt7#
-end#!alt7#
+class Object#alt7#
+end#alt7#
#alt6#class A
#alt6#end
#alt2#o = new B
#alt3#o = new B
#alt3#o.foo
-o = new A#!alt2#
+o = new A#alt2#
o.foo
# limitations under the License.
class A
- readable writable var _a: Int = 0#!alt1#
+ readable writable var _a: Int = 0#alt1#
#alt1#readable writable var _a: Object = 0
init do end
fun foo