1#!/usr/bin/ruby
2# encoding: utf-8
3
4require 'antlr3/test/functional'
5
6class TestASTConstructingParser < ANTLR3::Test::Functional
7
8  compile inline_grammar( <<-'END' )
9    grammar ASTBuilder;
10    options {
11      language = Ruby;
12      output = AST;
13    }
14
15    tokens {
16        VARDEF;
17        FLOAT;
18        EXPR;
19        BLOCK;
20        VARIABLE;
21        FIELD;
22        CALL;
23        INDEX;
24        FIELDACCESS;
25    }
26
27    @init {
28      @flag = false
29    }
30
31    @members {
32      attr_accessor :flag
33
34      def report_error(e)
35        # do nothing
36      end
37
38    }
39
40
41    r1
42        : INT ('+'^ INT)*
43        ;
44
45    r2
46        : 'assert'^ x=expression (':'! y=expression)? ';'!
47        ;
48
49    r3
50        : 'if'^ expression s1=statement ('else'! s2=statement)?
51        ;
52
53    r4
54        : 'while'^ expression statement
55        ;
56
57    r5
58        : 'return'^ expression? ';'!
59        ;
60
61    r6
62        : (INT|ID)+
63        ;
64
65    r7
66        : INT ->
67        ;
68
69    r8
70        : 'var' ID ':' type -> ^('var' type ID)
71        ;
72
73    r9
74        : type ID ';' -> ^(VARDEF type ID)
75        ;
76
77    r10
78        : INT -> { ANTLR3::AST::CommonTree.new(ANTLR3::CommonToken.create(:type => FLOAT, :text => ($INT.text + ".0")))}
79        ;
80
81    r11
82        : expression -> ^(EXPR expression)
83        | -> EXPR
84        ;
85
86    r12
87        : ID (',' ID)* -> ID+
88        ;
89
90    r13
91        : type ID (',' ID)* ';' -> ^(type ID+)
92        ;
93
94    r14
95        :   expression? statement* type+
96            -> ^(EXPR expression? statement* type+)
97        ;
98
99    r15
100        : INT -> INT INT
101        ;
102
103    r16
104        : 'int' ID (',' ID)* -> ^('int' ID)+
105        ;
106
107    r17
108        : 'for' '(' start=statement ';' expression ';' next=statement ')' statement
109            -> ^('for' $start expression $next statement)
110        ;
111
112    r18
113        : t='for' -> ^(BLOCK)
114        ;
115
116    r19
117        : t='for' -> ^(BLOCK[$t])
118        ;
119
120    r20
121        : t='for' -> ^(BLOCK[$t,"FOR"])
122        ;
123
124    r21
125        : t='for' -> BLOCK
126        ;
127
128    r22
129        : t='for' -> BLOCK[$t]
130        ;
131
132    r23
133        : t='for' -> BLOCK[$t,"FOR"]
134        ;
135
136    r24
137        : r=statement expression -> ^($r expression)
138        ;
139
140    r25
141        : r+=statement (',' r+=statement)+ expression -> ^($r expression)
142        ;
143
144    r26
145        : r+=statement (',' r+=statement)+ -> ^(BLOCK $r+)
146        ;
147
148    r27
149        : r=statement expression -> ^($r ^($r expression))
150        ;
151
152    r28
153        : ('foo28a'|'foo28b') ->
154        ;
155
156    r29
157        : (r+=statement)* -> ^(BLOCK $r+)
158        ;
159
160    r30
161        : statement* -> ^(BLOCK statement?)
162        ;
163
164    r31
165        : modifier type ID ('=' expression)? ';'
166            -> {@flag == 0}? ^(VARDEF ID modifier* type expression?)
167            -> {@flag == 1}? ^(VARIABLE ID modifier* type expression?)
168            ->                   ^(FIELD ID modifier* type expression?)
169        ;
170
171    r32[which]
172      : ID INT -> {which==1}? ID
173               -> {which==2}? INT
174               -> // yield nothing as else-clause
175      ;
176
177    r33
178        :   modifiers! statement
179        ;
180
181    r34
182        :   modifiers! r34a[$modifiers.tree]
183        //|   modifiers! r33b[$modifiers.tree]
184        ;
185
186    r34a[mod]
187        :   'class' ID ('extends' sup=type)?
188            ( 'implements' i+=type (',' i+=type)*)?
189            '{' statement* '}'
190            -> ^('class' ID {$mod} ^('extends' $sup)? ^('implements' $i+)? statement* )
191        ;
192
193    r35
194        : '{' 'extends' (sup=type)? '}'
195            ->  ^('extends' $sup)?
196        ;
197
198    r36
199        : 'if' '(' expression ')' s1=statement
200            ( 'else' s2=statement -> ^('if' ^(EXPR expression) $s1 $s2)
201            |                     -> ^('if' ^(EXPR expression) $s1)
202            )
203        ;
204
205    r37
206        : (INT -> INT) ('+' i=INT -> ^('+' $r37 $i) )*
207        ;
208
209    r38
210        : INT ('+'^ INT)*
211        ;
212
213    r39
214        : (primary->primary) // set return tree to just primary
215            ( '(' arg=expression ')'
216                -> ^(CALL $r39 $arg)
217            | '[' ie=expression ']'
218                -> ^(INDEX $r39 $ie)
219            | '.' p=primary
220                -> ^(FIELDACCESS $r39 $p)
221            )*
222        ;
223
224    r40
225        : (INT -> INT) ( ('+' i+=INT)* -> ^('+' $r40 $i*) ) ';'
226        ;
227
228    r41
229        : (INT -> INT) ( ('+' i=INT) -> ^($i $r41) )* ';'
230        ;
231
232    r42
233        : ids+=ID (','! ids+=ID)*
234        ;
235
236    r43 returns [res]
237        : ids+=ID! (','! ids+=ID!)* {$res = $ids.map { |id| id.text }}
238        ;
239
240    r44
241        : ids+=ID^ (','! ids+=ID^)*
242        ;
243
244    r45
245        : primary^
246        ;
247
248    r46 returns [res]
249        : ids+=primary! (','! ids+=primary!)* {$res = $ids.map { |id| id.text }}
250        ;
251
252    r47
253        : ids+=primary (','! ids+=primary)*
254        ;
255
256    r48
257        : ids+=. (','! ids+=.)*
258        ;
259
260    r49
261        : .^ ID
262        ;
263
264    r50
265        : ID
266            -> ^({ANTLR3::AST::CommonTree.new(ANTLR3::CommonToken.create(:type => FLOAT, :text => "1.0"))} ID)
267        ;
268
269    /** templates tested:
270        tokenLabelPropertyRef_tree
271    */
272    r51 returns [res]
273        : ID t=ID ID
274            { $res = $t.tree }
275        ;
276
277    /** templates tested:
278        rulePropertyRef_tree
279    */
280    r52 returns [res]
281    @after {
282        $res = $tree
283    }
284        : ID
285        ;
286
287    /** templates tested:
288        ruleLabelPropertyRef_tree
289    */
290    r53 returns [res]
291        : t=primary
292            { $res = $t.tree }
293        ;
294
295    /** templates tested:
296        ruleSetPropertyRef_tree
297    */
298    r54 returns [res]
299    @after {
300        $tree = $t.tree;
301    }
302        : ID t=expression ID
303        ;
304
305    /** backtracking */
306    r55
307    options { backtrack=true; k=1; }
308        : (modifier+ INT)=> modifier+ expression
309        | modifier+ statement
310        ;
311
312
313    /** templates tested:
314        rewriteTokenRef with len(args)>0
315    */
316    r56
317        : t=ID* -> ID[$t,'foo']
318        ;
319
320    /** templates tested:
321        rewriteTokenRefRoot with len(args)>0
322    */
323    r57
324        : t=ID* -> ^(ID[$t,'foo'])
325        ;
326
327    /** templates tested:
328        ???
329    */
330    r58
331        : ({CommonTree.new(CommonToken.create(:type => FLOAT, :text => "2.0"))})^
332        ;
333
334    /** templates tested:
335        rewriteTokenListLabelRefRoot
336    */
337    r59
338        : (t+=ID)+ statement -> ^($t statement)+
339        ;
340
341    primary
342        : ID
343        ;
344
345    expression
346        : r1
347        ;
348
349    statement
350        : 'fooze'
351        | 'fooze2'
352        ;
353
354    modifiers
355        : modifier+
356        ;
357
358    modifier
359        : 'public'
360        | 'private'
361        ;
362
363    type
364        : 'int'
365        | 'bool'
366        ;
367
368    ID : 'a'..'z' + ;
369    INT : '0'..'9' +;
370    WS: (' ' | '\n' | '\t')+ {$channel = HIDDEN;};
371  END
372
373  def self.ast_test( opts, &special_test )
374    input = opts[ :input ]
375    rule  = opts[ :rule ]
376    expected_tree = opts[ :ast ]
377    flag = opts[ :flag ]
378    args = opts[ :arguments ] || []
379    message = opts[ :message ] || rule.to_s #"should parse %p with rule %s and make tree %s" % [input, rule, expected_tree]
380
381    example( message ) do
382      lexer = ASTBuilder::Lexer.new( input )
383      parser = ASTBuilder::Parser.new( lexer )
384      parser.flag = flag unless flag.nil?
385      result = parser.send( rule, *args )
386      if special_test then instance_exec( result, &special_test )
387      elsif expected_tree then
388        result.tree.inspect.should == expected_tree
389      else result.tree.should be_nil
390      end
391    end
392  end
393
394  ast_test :input => "1 + 2", :rule => :r1, :ast => "(+ 1 2)"
395
396  ast_test :input => "assert 2+3", :rule => :r2, :ast => "(assert (+ 2 3))"
397
398  ast_test :input => "assert 2+3 : 5", :rule => :r2, :ast => "(assert (+ 2 3) 5)"
399
400  ast_test :input => "if 1 fooze", :rule => :r3, :ast => "(if 1 fooze)"
401
402  ast_test :input => "if 1 fooze else fooze", :rule => :r3, :ast => "(if 1 fooze fooze)"
403
404  ast_test :input => "while 2 fooze", :rule => :r4, :ast => "(while 2 fooze)"
405
406  ast_test :input => "return;", :rule => :r5, :ast => "return"
407
408  ast_test :input => "return 2+3;", :rule => :r5, :ast => "(return (+ 2 3))"
409
410  ast_test :input => "3", :rule => :r6, :ast => "3"
411
412  ast_test :input => "3 a", :rule => :r6, :ast => "3 a"
413
414  ast_test :input => "3", :rule => :r7, :ast => nil
415
416  ast_test :input => "var foo:bool", :rule => :r8, :ast => "(var bool foo)"
417
418  ast_test :input => "int foo;", :rule => :r9, :ast => "(VARDEF int foo)"
419
420  ast_test :input => "10", :rule => :r10, :ast => "10.0"
421
422  ast_test :input => "1+2", :rule => :r11, :ast => "(EXPR (+ 1 2))"
423
424  ast_test :input => "", :rule => :r11, :ast => "EXPR"
425
426  ast_test :input => "foo", :rule => :r12, :ast => "foo"
427
428  ast_test :input => "foo, bar, gnurz", :rule => :r12, :ast => "foo bar gnurz"
429
430  ast_test :input => "int foo;", :rule => :r13, :ast => "(int foo)"
431
432  ast_test :input => "bool foo, bar, gnurz;", :rule => :r13, :ast => "(bool foo bar gnurz)"
433
434  ast_test :input => "1+2 int", :rule => :r14, :ast => "(EXPR (+ 1 2) int)"
435
436  ast_test :input => "1+2 int bool", :rule => :r14, :ast => "(EXPR (+ 1 2) int bool)"
437
438  ast_test :input => "int bool", :rule => :r14, :ast => "(EXPR int bool)"
439
440  ast_test :input => "fooze fooze int bool", :rule => :r14, :ast => "(EXPR fooze fooze int bool)"
441
442  ast_test :input => "7+9 fooze fooze int bool", :rule => :r14, :ast => "(EXPR (+ 7 9) fooze fooze int bool)"
443
444  ast_test :input => "7", :rule => :r15, :ast => "7 7"
445
446  ast_test :input => "int foo", :rule => :r16, :ast => "(int foo)"
447
448  ast_test :input => "int foo, bar, gnurz", :rule => :r16, :ast => "(int foo) (int bar) (int gnurz)"
449
450  ast_test :input => "for ( fooze ; 1 + 2 ; fooze ) fooze", :rule => :r17, :ast => "(for fooze (+ 1 2) fooze fooze)"
451
452  ast_test :input => "for", :rule => :r18, :ast => "BLOCK"
453
454  ast_test :input => "for", :rule => :r19, :ast => "for"
455
456  ast_test :input => "for", :rule => :r20, :ast => "FOR"
457
458  ast_test :input => "for", :rule => :r21, :ast => "BLOCK"
459
460  ast_test :input => "for", :rule => :r22, :ast => "for"
461
462  ast_test :input => "for", :rule => :r23, :ast => "FOR"
463
464  ast_test :input => "fooze 1 + 2", :rule => :r24, :ast => "(fooze (+ 1 2))"
465
466  ast_test :input => "fooze, fooze2 1 + 2", :rule => :r25, :ast => "(fooze (+ 1 2))"
467
468  ast_test :input => "fooze, fooze2", :rule => :r26, :ast => "(BLOCK fooze fooze2)"
469
470  ast_test :input => "fooze 1 + 2", :rule => :r27, :ast => "(fooze (fooze (+ 1 2)))"
471
472  ast_test :input => "foo28a", :rule => :r28, :ast => nil
473
474  ast_test :input => "public int gnurz = 1 + 2;", :rule => :r31, :ast => "(VARDEF gnurz public int (+ 1 2))", :flag => 0
475
476  ast_test :input => "public int gnurz = 1 + 2;", :rule => :r31, :ast => "(VARIABLE gnurz public int (+ 1 2))", :flag => 1
477
478  ast_test :input => "public int gnurz = 1 + 2;", :rule => :r31, :ast => "(FIELD gnurz public int (+ 1 2))", :flag => 2
479
480  ast_test :input => 'gnurz 32', :rule => :r32, :arguments => [ 1 ], :flag => 2, :ast => 'gnurz'
481
482  ast_test :input => 'gnurz 32', :rule => :r32, :arguments => [ 2 ], :flag => 2, :ast => '32'
483
484  ast_test :input => 'gnurz', :rule => :r32, :arguments => [ 3 ], :flag => 2, :ast => nil
485
486  ast_test :input => "public private fooze", :rule => :r33, :ast => "fooze"
487
488  ast_test :input => "public class gnurz { fooze fooze2 }", :rule => :r34, :ast => "(class gnurz public fooze fooze2)"
489
490  ast_test :input => "public class gnurz extends bool implements int, bool { fooze fooze2 }", :rule => :r34, :ast => "(class gnurz public (extends bool) (implements int bool) fooze fooze2)"
491
492  ast_test :input => "if ( 1 + 2 ) fooze", :rule => :r36, :ast => "(if (EXPR (+ 1 2)) fooze)"
493
494  ast_test :input => "1 + 2 + 3", :rule => :r37, :ast => "(+ (+ 1 2) 3)"
495
496  ast_test :input => "1 + 2 + 3", :rule => :r38, :ast => "(+ (+ 1 2) 3)"
497
498  ast_test :input => "gnurz[1]", :rule => :r39, :ast => "(INDEX gnurz 1)"
499
500  ast_test :input => "gnurz(2)", :rule => :r39, :ast => "(CALL gnurz 2)"
501
502  ast_test :input => "gnurz.gnarz", :rule => :r39, :ast => "(FIELDACCESS gnurz gnarz)"
503
504  ast_test :input => "gnurz.gnarz.gnorz", :rule => :r39, :ast => "(FIELDACCESS (FIELDACCESS gnurz gnarz) gnorz)"
505
506  ast_test :input => "1 + 2 + 3;", :rule => :r40, :ast => "(+ 1 2 3)"
507
508  ast_test :input => "1 + 2 + 3;", :rule => :r41, :ast => "(3 (2 1))"
509
510  ast_test :input => "gnurz, gnarz, gnorz", :rule => :r42, :ast => "gnurz gnarz gnorz"
511
512  ast_test :input => "gnurz, gnarz, gnorz", :rule => :r43 do |result|
513    result.tree.should be_nil
514    result.res.should == %w(gnurz gnarz gnorz)
515  end
516
517  ast_test :input => 'gnurz, gnarz, gnorz', :rule => :r44, :ast => '(gnorz (gnarz gnurz))'
518
519  ast_test :input => 'gnurz', :rule => :r45, :ast => 'gnurz'
520
521  ast_test :input => 'gnurz, gnarz, gnorz', :rule => :r46 do |result|
522    result.tree.should be_nil
523    result.res.should == %w(gnurz gnarz gnorz)
524  end
525
526  ast_test :input => 'gnurz, gnarz, gnorz', :rule => :r47, :ast => 'gnurz gnarz gnorz'
527
528  ast_test :input => 'gnurz, gnarz, gnorz', :rule => :r48, :ast => 'gnurz gnarz gnorz'
529
530  ast_test :input => 'gnurz gnorz', :rule => :r49, :ast => '(gnurz gnorz)'
531
532  ast_test :input => 'gnurz', :rule => :r50, :ast => '(1.0 gnurz)'
533
534  ast_test :input => 'gnurza gnurzb gnurzc', :rule => :r51 do |result|
535    result.res.inspect.should == 'gnurzb'
536  end
537
538  ast_test :input => 'gnurz', :rule => :r52, :ast => 'gnurz'
539
540  ast_test :input => 'gnurz', :rule => :r53, :ast => 'gnurz'
541
542  ast_test :input => 'gnurza 1 + 2 gnurzb', :rule => :r54, :ast => '(+ 1 2)'
543
544  ast_test :input => 'public private 1 + 2', :rule => :r55, :ast => 'public private (+ 1 2)'
545
546  ast_test :input => 'public fooze', :rule => :r55, :ast => 'public fooze'
547
548  ast_test :input => 'a b c d', :rule => :r56, :ast => 'foo'
549
550  ast_test :input => 'a b c d', :rule => :r57, :ast => 'foo'
551
552  ast_test :input => 'a b c fooze', :rule => :r59, :ast => '(a fooze) (b fooze) (c fooze)'
553
554end
555