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