Added tree adaptor for new AST node type
[charm.git] / src / langs / charj / src / charj / translator / CharjEmitter.g
1 /**
2  * ANTLR (v3) Tree Parser for the Charj Language
3  */
4
5 tree grammar CharjEmitter;
6
7 options {
8     backtrack = true; 
9     memoize = true;
10     tokenVocab = Charj;
11     ASTLabelType = CharjAST;
12     output = template;
13 }
14
15
16 @header {
17 package charj.translator;
18 }
19
20 @members {
21     OutputMode m_mode;
22     boolean m_messageCollectionEnabled = false;
23     private boolean m_hasErrors = false;
24     List<String> m_messages;
25
26     private boolean emitCC() { return m_mode == OutputMode.cc; }
27     private boolean emitCI() { return m_mode == OutputMode.ci; }
28     private boolean emitH() { return m_mode == OutputMode.h; }
29
30     /**
31      *  Switches error message collection on or off.
32      *
33      *  The standard destination for parser error messages is 
34      *  <code>System.err</code>.
35      *  However, if <code>true</code> gets passed to this method this default
36      *  behaviour will be switched off and all error messages will be collected
37      *  instead of written to anywhere.
38      *
39      *  The default value is <code>false</code>.
40      *
41      *  @param newState  <code>true</code> if error messages should be collected.
42      */
43     public void enableErrorMessageCollection(boolean newState) {
44         m_messageCollectionEnabled = newState;
45         if (m_messages == null && m_messageCollectionEnabled) {
46             m_messages = new ArrayList<String>();
47         }
48     }
49     
50     /**
51      *  Collects an error message or passes the error message to <code>
52      *  super.emitErrorMessage(...)</code>.
53      *
54      *  The actual behaviour depends on whether collecting error messages
55      *  has been enabled or not.
56      *
57      *  @param message  The error message.
58      */
59      @Override
60     public void emitErrorMessage(String message) {
61         if (m_messageCollectionEnabled) {
62             m_messages.add(message);
63         } else {
64             super.emitErrorMessage(message);
65         }
66     }
67     
68     /**
69      *  Returns collected error messages.
70      *
71      *  @return  A list holding collected error messages or <code>null</code> if
72      *           collecting error messages hasn't been enabled. Of course, this
73      *           list may be empty if no error message has been emited.
74      */
75     public List<String> getMessages() {
76         return m_messages;
77     }
78     
79     /**
80      *  Tells if parsing a Charj source has caused any error messages.
81      *
82      *  @return  <code>true</code> if parsing a Charj source has caused at 
83      *           least one error message.
84      */
85     public boolean hasErrors() {
86         return m_hasErrors;
87     }
88 }
89
90 // Starting point for parsing a Charj file.
91 charjSource[OutputMode m]
92 @init {
93     this.m_mode = m;
94 }
95     :   ^(CHARJ_SOURCE (p=packageDeclaration)? (i+=importDeclaration)* (t+=typeDeclaration)*)
96         -> {emitCC()}? charjSource_cc(pd={$p.st}, ids={$i}, tds={$t})
97         -> {emitCI()}? charjSource_ci(pd={$p.st}, ids={$i}, tds={$t})
98         -> {emitH()}? charjSource_h(pd={$p.st}, ids={$i}, tds={$t})
99         ->
100     ;
101
102 packageDeclaration
103     :   ^(PACKAGE qualifiedIdentifier)  
104         -> template(t={$text}) "//<t>"
105     ;
106     
107 importDeclaration
108     :   ^(IMPORT STATIC? qualifiedIdentifier DOTSTAR?)
109         -> template(t={$text}) "//<t>"
110     ;
111     
112 typeDeclaration
113     :   ^(CLASS m=modifierList IDENT g=genericTypeParameterList? 
114                 e=classExtendsClause? i=implementsClause? c=classTopLevelScope) 
115         -> {emitCC()}? classDeclaration_cc(
116                 mod={$m.st}, 
117                 ident={$IDENT.text}, 
118                 gen={$g.st}, 
119                 ext={$e.st}, 
120                 impl={$i.st},
121                 ctls={$c.st})
122         -> {emitCI()}? classDeclaration_ci(
123                 mod={$m.st}, 
124                 ident={$IDENT.text}, 
125                 gen={$g.st}, 
126                 ext={$e.st}, 
127                 impl={$i.st},
128                 ctls={$c.st})
129         -> {emitH()}? classDeclaration_h(
130                 mod={$m.st}, 
131                 ident={$IDENT.text}, 
132                 gen={$g.st}, 
133                 ext={$e.st}, 
134                 impl={$i.st},
135                 ctls={$c.st})
136         ->
137     |   ^(INTERFACE modifierList IDENT genericTypeParameterList? 
138                 interfaceExtendsClause? interfaceTopLevelScope)
139         -> template(t={$text}) "<t>"
140     |   ^(ENUM modifierList IDENT implementsClause? enumTopLevelScope)
141         -> template(t={$text}) "<t>"
142     ;
143
144
145 classExtendsClause
146     :   ^(EXTENDS_CLAUSE t=type) 
147         -> {emitCC() || emitH()}? classExtends_cc_h(type={$t.st})
148         -> {emitCI()}? classExtends_ci(type={$t.st})
149         ->
150     ;   
151
152 interfaceExtendsClause 
153     :   ^(EXTENDS_CLAUSE (typeList+=type)+) 
154         -> interfaceExtends(ts={$typeList})
155     ;   
156     
157 implementsClause
158     :   ^(IMPLEMENTS_CLAUSE type+)
159         -> template(t={$text}) "<t>"
160     ;
161         
162 genericTypeParameterList
163     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
164         -> template(t={$text}) "<t>"
165     ;
166
167 genericTypeParameter
168     :   ^(IDENT bound?)
169         -> template(t={$text}) "<t>"
170     ;
171         
172 bound
173     :   ^(EXTENDS_BOUND_LIST type+)
174         -> template(t={$text}) "<t>"
175     ;
176
177 enumTopLevelScope
178     :   ^(ENUM_TOP_LEVEL_SCOPE enumConstant+ classTopLevelScope?)
179         -> template(t={$text}) "<t>"
180     ;
181     
182 enumConstant
183     :   ^(IDENT arguments? classTopLevelScope?)
184         -> template(t={$text}) "<t>"
185     ;
186     
187     
188 classTopLevelScope
189     :   ^(CLASS_TOP_LEVEL_SCOPE (csd+=classScopeDeclarations)*) 
190         -> classTopLevelScope(classScopeDeclarations={$csd})
191     ;
192     
193 classScopeDeclarations
194 //@init { boolean entry = false; }
195     :   ^(CLASS_INSTANCE_INITIALIZER block)
196         -> template(t={$text}) "/*cii*/ <t>"
197     |   ^(CLASS_STATIC_INITIALIZER block)
198         -> template(t={$text}) "/*csi*/ <t>"
199     |   ^(FUNCTION_METHOD_DECL m=modifierList g=genericTypeParameterList? 
200             ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
201             tc=throwsClause? b=block?)
202 //        { 
203 //            // determine whether this is an entry method
204 //            CharjAST modList = (CharjAST)$m.start;
205 //            for (CharjAST mod : (List<CharjAST>)modList.getChildren()) {
206 //                if (mod.token.getType() == ENTRY) {
207 //                    entry = true;
208 //                }
209 //            }
210 //        }
211         -> {emitCC()}? funcMethodDecl_cc(
212                 modl={$m.st}, 
213                 gtpl={$g.st}, 
214                 ty={$ty.text},
215                 id={$IDENT.text}, 
216                 fpl={$f.st}, 
217                 adl={$a.st},
218                 tc={$tc.st}, 
219                 block={$b.st})
220         -> {emitH()}? funcMethodDecl_h(
221                 modl={$m.st}, 
222                 gtpl={$g.st}, 
223                 ty={$ty.text},
224                 id={$IDENT.text}, 
225                 fpl={$f.st}, 
226                 adl={$a.st},
227                 tc={$tc.st}, 
228                 block={$b.st})
229 //        -> {(emitCI() && entry)}? funcMethodDecl_ci(
230 //                modl={$m.st}, 
231 //                gtpl={$g.st}, 
232 //                ty={$ty.text},
233 //                id={$IDENT.text}, 
234 //                fpl={$f.st}, 
235 //                adl={$a.st},
236 //                tc={$tc.st}, 
237 //                block={$b.st})
238         ->
239     |   ^(VOID_METHOD_DECL m=modifierList g=genericTypeParameterList? IDENT 
240             f=formalParameterList t=throwsClause? b=block?)
241         -> {emitCC()}? voidMethodDecl_cc(
242                 modl={$m.st}, 
243                 gtpl={$g.st}, 
244                 id={$IDENT.text}, 
245                 fpl={$f.st}, 
246                 tc={$t.st}, 
247                 block={$b.st})
248         -> {emitCI()}? voidMethodDecl_ci(
249                 modl={$m.st}, 
250                 gtpl={$g.st}, 
251                 id={$IDENT.text}, 
252                 fpl={$f.st}, 
253                 tc={$t.st}, 
254                 block={$b.st})
255         -> {emitH()}? voidMethodDecl_h(
256                 modl={$m.st}, 
257                 gtpl={$g.st}, 
258                 id={$IDENT.text}, 
259                 fpl={$f.st}, 
260                 tc={$t.st}, 
261                 block={$b.st})
262         ->
263
264 // template(t={$text}) "/*voidmethod*/ <t>"
265     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
266         -> template(t={$text}) "vardecl <t>"
267     |   ^(CONSTRUCTOR_DECL m=modifierList g=genericTypeParameterList? IDENT f=formalParameterList 
268             t=throwsClause? b=block)
269         -> {emitCC()}? ctorDecl_cc(
270                 modl={$m.st}, 
271                 gtpl={$g.st}, 
272                 id={$IDENT.text}, 
273                 fpl={$f.st}, 
274                 tc={$t.st}, 
275                 block={$b.st})
276         -> {emitCI()}? ctorDecl_ci(
277                 modl={$m.st}, 
278                 gtpl={$g.st}, 
279                 id={$IDENT.text}, 
280                 fpl={$f.st}, 
281                 tc={$t.st}, 
282                 block={$b.st})
283         -> {emitH()}? ctorDecl_h(
284                 modl={$m.st}, 
285                 gtpl={$g.st}, 
286                 id={$IDENT.text}, 
287                 fpl={$f.st}, 
288                 tc={$t.st}, 
289                 block={$b.st})
290         ->
291     |   d=typeDeclaration
292         -> template(t={$d.st}) "type <t>"
293     ;
294     
295 interfaceTopLevelScope
296     :   ^(INTERFACE_TOP_LEVEL_SCOPE interfaceScopeDeclarations*)
297         -> template(t={$text}) "<t>"
298     ;
299     
300 interfaceScopeDeclarations
301     :   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
302         -> template(t={$text}) "<t>"
303     |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
304         -> template(t={$text}) "<t>"
305         // Interface constant declarations have been switched to variable
306         // declarations by Charj.g; the parser has already checked that
307         // there's an obligatory initializer.
308     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
309         -> template(t={$text}) "<t>"
310     |   typeDeclaration
311         -> template(t={$text}) "<t>"
312     ;
313
314 variableDeclaratorList
315     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
316         -> template(t={$text}) "<t>"
317     ;
318
319 variableDeclarator
320     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
321         -> template(t={$text}) "<t>"
322     ;
323     
324 variableDeclaratorId
325     :   ^(IDENT arrayDeclaratorList?)
326         -> template(t={$text}) "<t>"
327     ;
328
329 variableInitializer
330     :   arrayInitializer
331         -> template(t={$text}) "<t>"
332     |   expression
333         -> template(t={$text}) "<t>"
334     ;
335
336 arrayDeclarator
337     :   LBRACK RBRACK
338         -> template(t={$text}) "<t>"
339     ;
340
341 arrayDeclaratorList
342     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
343         -> template(t={$text}) "<t>"
344     ;
345     
346 arrayInitializer
347     :   ^(ARRAY_INITIALIZER variableInitializer*)
348         -> template(t={$text}) "<t>"
349     ;
350
351 throwsClause
352     :   ^(THROWS_CLAUSE qualifiedIdentifier+)
353         -> template(t={$text}) "<t>"
354     ;
355
356 modifierList
357     :   ^(MODIFIER_LIST (m+=modifier)*)
358         -> template(mod={$m}) "<mod; separator=\" \">"
359     ;
360
361 modifier
362     :   PUBLIC
363         -> template(t={$text}) "<t>"
364     |   PROTECTED
365         -> template(t={$text}) "<t>"
366     |   PRIVATE
367         -> template(t={$text}) "<t>"
368     |   ENTRY
369         -> template() "public"
370     |   STATIC
371         -> template(t={$text}) "<t>"
372     |   ABSTRACT
373         -> template(t={$text}) "<t>"
374     |   NATIVE
375         -> template(t={$text}) "<t>"
376     |   SYNCHRONIZED
377         -> template(t={$text}) "<t>"
378     |   TRANSIENT
379         -> template(t={$text}) "<t>"
380     |   VOLATILE
381         -> template(t={$text}) "<t>"
382     |   localModifier
383         -> template(t={$text}) "<t>"
384     ;
385
386 localModifierList
387     :   ^(LOCAL_MODIFIER_LIST localModifier*)
388         -> template(t={$text}) "<t>"
389     ;
390
391 localModifier
392     :   FINAL
393         -> template(t={$text}) "<t>"
394     ;
395
396 type
397     :   ^(TYPE (primitiveType | qualifiedTypeIdent) arrayDeclaratorList?) 
398         -> template(t={$text}) "<t>"
399     ;
400
401 qualifiedTypeIdent
402     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
403         -> template(t={$text}) "<t>"
404     ;
405
406 typeIdent
407     :   ^(IDENT genericTypeArgumentList?)
408         -> template(t={$text}) "<t>"
409     ;
410
411 primitiveType
412     :   BOOLEAN
413         -> template(t={$text}) "<t>"
414     |   CHAR
415         -> template(t={$text}) "<t>"
416     |   BYTE
417         -> template(t={$text}) "<t>"
418     |   SHORT
419         -> template(t={$text}) "<t>"
420     |   INT
421         -> template(t={$text}) "<t>"
422     |   LONG
423         -> template(t={$text}) "<t>"
424     |   FLOAT
425         -> template(t={$text}) "<t>"
426     |   DOUBLE
427         -> template(t={$text}) "<t>"
428     ;
429
430 genericTypeArgumentList
431     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
432         -> template(t={$text}) "<t>"
433     ;
434     
435 genericTypeArgument
436     :   type
437         -> template(t={$text}) "<t>"
438     |   ^(QUESTION genericWildcardBoundType?)
439         -> template(t={$text}) "<t>"
440     ;
441
442 genericWildcardBoundType                                                                                                                      
443     :   ^(EXTENDS type)
444         -> template(t={$text}) "<t>"
445     |   ^(SUPER type)
446         -> template(t={$text}) "<t>"
447     ;
448
449 formalParameterList
450     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
451         -> template(t={$text}) "<t>"
452     ;
453     
454 formalParameterStandardDecl
455     :   ^(FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId)
456         -> template(t={$text}) "<t>"
457     ;
458     
459 formalParameterVarargDecl
460     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
461         -> template(t={$text}) "<t>"
462     ;
463     
464 qualifiedIdentifier
465     :   IDENT
466         -> template(t={$text}) "<t>"
467     |   ^(DOT qualifiedIdentifier IDENT)
468         -> template(t={$text}) "<t>"
469     ;
470     
471 block
472     :   ^(BLOCK_SCOPE blockStatement*)
473         -> template(t={$text}) "<t>"
474     ;
475     
476 blockStatement
477     :   localVariableDeclaration
478         -> template(t={$text}) "<t>"
479     |   typeDeclaration
480         -> template(t={$text}) "<t>"
481     |   statement
482         -> template(t={$text}) "<t>"
483     ;
484     
485 localVariableDeclaration
486     :   ^(VAR_DECLARATION localModifierList type variableDeclaratorList)
487         -> template(t={$text}) "<t>"
488     ;
489     
490         
491 statement
492     :   block
493         -> template(t={$text}) "<t>"
494     |   ^(ASSERT expression expression?)
495         -> template(t={$text}) "<t>"
496     |   ^(IF parenthesizedExpression statement statement?)
497         -> template(t={$text}) "<t>"
498     |   ^(FOR forInit forCondition forUpdater statement)
499         -> template(t={$text}) "<t>"
500     |   ^(FOR_EACH localModifierList type IDENT expression statement) 
501         -> template(t={$text}) "<t>"
502     |   ^(WHILE parenthesizedExpression statement)
503         -> template(t={$text}) "<t>"
504     |   ^(DO statement parenthesizedExpression)
505         -> template(t={$text}) "<t>"
506     |   ^(TRY block catches? block?)  // The second optional block is the optional finally block.
507         -> template(t={$text}) "<t>"
508     |   ^(SWITCH parenthesizedExpression switchBlockLabels)
509         -> template(t={$text}) "<t>"
510     |   ^(SYNCHRONIZED parenthesizedExpression block)
511         -> template(t={$text}) "<t>"
512     |   ^(RETURN expression?)
513         -> template(t={$text}) "<t>"
514     |   ^(THROW expression)
515         -> template(t={$text}) "<t>"
516     |   ^(BREAK IDENT?)
517         -> template(t={$text}) "<t>"
518     |   ^(CONTINUE IDENT?)
519         -> template(t={$text}) "<t>"
520     |   ^(LABELED_STATEMENT IDENT statement)
521         -> template(t={$text}) "<t>"
522     |   expression
523         -> template(t={$text}) "<t>"
524     |   SEMI // Empty statement.
525         -> template(t={$text}) "<t>"
526     ;
527         
528 catches
529     :   ^(CATCH_CLAUSE_LIST catchClause+)
530         -> template(t={$text}) "<t>"
531     ;
532     
533 catchClause
534     :   ^(CATCH formalParameterStandardDecl block)
535         -> template(t={$text}) "<t>"
536     ;
537
538 switchBlockLabels
539     :   ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabel* switchDefaultLabel? switchCaseLabel*)
540         -> template(t={$text}) "<t>"
541     ;
542         
543 switchCaseLabel
544     :   ^(CASE expression blockStatement*)
545         -> template(t={$text}) "<t>"
546     ;
547     
548 switchDefaultLabel
549     :   ^(DEFAULT blockStatement*)
550         -> template(t={$text}) "<t>"
551     ;
552     
553 forInit
554     :   ^(FOR_INIT (localVariableDeclaration | expression*)?)
555         -> template(t={$text}) "<t>"
556     ;
557     
558 forCondition
559     :   ^(FOR_CONDITION expression?)
560         -> template(t={$text}) "<t>"
561     ;
562     
563 forUpdater
564     :   ^(FOR_UPDATE expression*)
565         -> template(t={$text}) "<t>"
566     ;
567     
568 // EXPRESSIONS
569
570 parenthesizedExpression
571     :   ^(PARENTESIZED_EXPR expression)
572         -> template(t={$text}) "<t>"
573     ;
574     
575 expression
576     :   ^(EXPR expr)
577         -> template(t={$text}) "<t>"
578     ;
579
580 expr
581     :   ^(ASSIGN expr expr)
582         -> template(t={$text}) "<t>"
583     |   ^(PLUS_ASSIGN expr expr)
584         -> template(t={$text}) "<t>"
585     |   ^(MINUS_ASSIGN expr expr)
586         -> template(t={$text}) "<t>"
587     |   ^(STAR_ASSIGN expr expr)
588         -> template(t={$text}) "<t>"
589     |   ^(DIV_ASSIGN expr expr)
590         -> template(t={$text}) "<t>"
591     |   ^(AND_ASSIGN expr expr)
592         -> template(t={$text}) "<t>"
593     |   ^(OR_ASSIGN expr expr)
594         -> template(t={$text}) "<t>"
595     |   ^(XOR_ASSIGN expr expr)
596         -> template(t={$text}) "<t>"
597     |   ^(MOD_ASSIGN expr expr)
598         -> template(t={$text}) "<t>"
599     |   ^(BIT_SHIFT_RIGHT_ASSIGN expr expr)
600         -> template(t={$text}) "<t>"
601     |   ^(SHIFT_RIGHT_ASSIGN expr expr)
602         -> template(t={$text}) "<t>"
603     |   ^(SHIFT_LEFT_ASSIGN expr expr)
604         -> template(t={$text}) "<t>"
605     |   ^(QUESTION expr expr expr)
606         -> template(t={$text}) "<t>"
607     |   ^(LOGICAL_OR expr expr)
608         -> template(t={$text}) "<t>"
609     |   ^(LOGICAL_AND expr expr)
610         -> template(t={$text}) "<t>"
611     |   ^(OR expr expr)
612         -> template(t={$text}) "<t>"
613     |   ^(XOR expr expr)
614         -> template(t={$text}) "<t>"
615     |   ^(AND expr expr)
616         -> template(t={$text}) "<t>"
617     |   ^(EQUAL expr expr)
618         -> template(t={$text}) "<t>"
619     |   ^(NOT_EQUAL expr expr)
620         -> template(t={$text}) "<t>"
621     |   ^(INSTANCEOF expr type)
622         -> template(t={$text}) "<t>"
623     |   ^(LESS_OR_EQUAL expr expr)
624         -> template(t={$text}) "<t>"
625     |   ^(GREATER_OR_EQUAL expr expr)
626         -> template(t={$text}) "<t>"
627     |   ^(BIT_SHIFT_RIGHT expr expr)
628         -> template(t={$text}) "<t>"
629     |   ^(SHIFT_RIGHT expr expr)
630         -> template(t={$text}) "<t>"
631     |   ^(GREATER_THAN expr expr)
632         -> template(t={$text}) "<t>"
633     |   ^(SHIFT_LEFT expr expr)
634         -> template(t={$text}) "<t>"
635     |   ^(LESS_THAN expr expr)
636         -> template(t={$text}) "<t>"
637     |   ^(PLUS expr expr)
638         -> template(t={$text}) "<t>"
639     |   ^(MINUS expr expr)
640         -> template(t={$text}) "<t>"
641     |   ^(STAR expr expr)
642         -> template(t={$text}) "<t>"
643     |   ^(DIV expr expr)
644         -> template(t={$text}) "<t>"
645     |   ^(MOD expr expr)
646         -> template(t={$text}) "<t>"
647     |   ^(UNARY_PLUS expr)
648         -> template(t={$text}) "<t>"
649     |   ^(UNARY_MINUS expr)
650         -> template(t={$text}) "<t>"
651     |   ^(PRE_INC expr)
652         -> template(t={$text}) "<t>"
653     |   ^(PRE_DEC expr)
654         -> template(t={$text}) "<t>"
655     |   ^(POST_INC expr)
656         -> template(t={$text}) "<t>"
657     |   ^(POST_DEC expr)
658         -> template(t={$text}) "<t>"
659     |   ^(NOT expr)
660         -> template(t={$text}) "<t>"
661     |   ^(LOGICAL_NOT expr)
662         -> template(t={$text}) "<t>"
663     |   ^(CAST_EXPR type expr)
664         -> template(t={$text}) "<t>"
665     |   primaryExpression
666         -> template(t={$text}) "<t>"
667     ;
668     
669 primaryExpression
670     :   ^(  DOT
671             (   primaryExpression
672                 (   IDENT
673                 |   THIS
674                 |   SUPER
675                 |   innerNewExpression
676                 |   CLASS
677                 )
678             |   primitiveType CLASS
679             |   VOID CLASS
680             )
681         )
682         -> template(t={$text}) "<t>"
683     |   parenthesizedExpression
684         -> template(t={$text}) "<t>"
685     |   IDENT
686         -> template(t={$text}) "<t>"
687     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
688         -> template(t={$text}) "<t>"
689     |   explicitConstructorCall
690         -> template(t={$text}) "<t>"
691     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
692         -> template(t={$text}) "<t>"
693     |   literal
694         -> template(t={$text}) "<t>"
695     |   newExpression
696         -> template(t={$text}) "<t>"
697     |   THIS
698         -> template(t={$text}) "<t>"
699     |   arrayTypeDeclarator
700         -> template(t={$text}) "<t>"
701     |   SUPER
702         -> template(t={$text}) "<t>"
703     ;
704     
705 explicitConstructorCall
706     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
707         -> template(t={$text}) "<t>"
708     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
709         -> template(t={$text}) "<t>"
710     ;
711
712 arrayTypeDeclarator
713     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
714         -> template(t={$text}) "<t>"
715     ;
716
717 newExpression
718     :   ^(  STATIC_ARRAY_CREATOR
719             (   primitiveType newArrayConstruction
720             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
721             )
722         )
723         -> template(t={$text}) "<t>"
724     |   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? qualifiedTypeIdent arguments classTopLevelScope?)
725         -> template(t={$text}) "<t>"
726     ;
727
728 innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
729     :   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? IDENT arguments classTopLevelScope?)
730         -> template(t={$text}) "<t>"
731     ;
732     
733 newArrayConstruction
734     :   arrayDeclaratorList arrayInitializer
735         -> template(t={$text}) "<t>"
736     |   expression+ arrayDeclaratorList?
737         -> template(t={$text}) "<t>"
738     ;
739
740 arguments
741     :   ^(ARGUMENT_LIST expression*)
742         -> template(t={$text}) "<t>"
743     ;
744
745 literal 
746     :   HEX_LITERAL
747         -> template(t={$text}) "<t>"
748     |   OCTAL_LITERAL
749         -> template(t={$text}) "<t>"
750     |   DECIMAL_LITERAL
751         -> template(t={$text}) "<t>"
752     |   FLOATING_POINT_LITERAL
753         -> template(t={$text}) "<t>"
754     |   CHARACTER_LITERAL
755         -> template(t={$text}) "<t>"
756     |   STRING_LITERAL
757         -> template(t={$text}) "<t>"
758     |   TRUE
759         -> template(t={$text}) "<t>"
760     |   FALSE
761         -> template(t={$text}) "<t>"
762     |   NULL
763         -> template(t={$text}) "<t>"
764     ;