[WIP]Typescript target

.github/workflows/hosted.yml

@@ -163,6 +163,7 @@ jobs:
           go,
           java,
           javascript,
+          typescript,
           php,
           python2,
           python3,
@@ -230,7 +231,7 @@ jobs:
         architecture: 'x64'
 
     - name: Set up Node 14
-      if: matrix.target == 'javascript'
+      if: (matrix.target == 'javascript') || (matrix.target == 'typescript')
       uses: actions/setup-node@v3
       with:
         node-version: '14'

ANTLR-HOUSE-RULES.md

@@ -0,0 +1,28 @@
+# ANTLR HOUSE RULES
+
+*Last updated: Sept 10, 2022*
+
+This brief document describes best practices for us to all get along and for the benefit of the project.  Collaborating on this project poses a number of difficulties:
+
+* different native languages
+* different time zones
+* lack of common company or other organization as social glue
+* we are just github userids without personal connection to most other contributors
+* those developers able to contribute to such a complex project typically have a lot of experience and, consequently, strong opinions
+
+Effective communication is difficult under the circumstances and civil discourse is a requirement to keep the project on track.  Over 35 years, in-fighting between contributors has made parrt's job as supreme dictator for life much more difficult.
+
+Rules
+
+1. Assume good intentions of the other party.
+2. Try to be welcoming and respectful of differing viewpoints experiences.
+2. No personal attacks, meaning ideas can be bad in your comments but not people.  Replace "You are ..." with "Your idea is ...".
+3. Control your anger please. No hate speech, racism, sexism, or ethnocentrism. No trolling or insulting. See rule #1.
+2. Be tolerant and understanding of non-native English speakers' word choice and phrasing.  This is a huge source of misunderstandings; see rule #1. For example, to a native English speaker "I cannot *approve* this" makes it sound like the writer has control over the readers contribution. Instead, the writer likely meant "I cannot *support* this." See rule #1.
+3. Soften word choice to use conditional tenses and helper words. For example, use phrases such as "I'm not sure this is a good idea because ..." or "I wonder if you'd consider this other possibility: ..." etc...
+
+Supreme dictator for life parrt has final say. His decisions will not always be correct nor to your liking, but he has a difficult cost-benefit equation to solve for every bug fix, feature, and PR.
+
+Any text contrary to these house rules will likely be edited and replaced with an admonishment by parrt.
+
+Send concerns to parrt@antlr.org.

runtime/Swift/Package.swift → Package.swift

@@ -14,13 +14,17 @@ let package = Package(
         .target(
             name: "Antlr4",
             dependencies: [],
-            path: "Sources/Antlr4"),
+            path: "./runtime/Swift/Sources/Antlr4"),
         .testTarget(
             name: "Antlr4Tests",
             dependencies: ["Antlr4"],
-            path:"Tests/Antlr4Tests",
+            path: "./runtime/Swift/Tests/Antlr4Tests",
             exclude: [
-                "VisitorBasic.g4", "VisitorCalc.g4", "LexerA.g4", "LexerB.g4", "Threading.g4"
+                "./runtime/Swift/Tests/VisitorBasic.g4",
+                "./runtime/Swift/Tests/VisitorCalc.g4",
+                "./runtime/Swift/Tests/LexerA.g4",
+                "./runtime/Swift/Tests/LexerB.g4",
+                "./runtime/Swift/Tests/Threading.g4"
             ]
         )
     ]

doc/getting-started.md

@@ -1,10 +1,134 @@
 # Getting Started with ANTLR v4
 
-Hi and welcome to the version 4 release of ANTLR! It's named after the fearless hero of the [Crazy Nasty-Ass Honey Badger](http://www.youtube.com/watch?v=4r7wHMg5Yjg) since ANTLR v4 takes whatever you give it--it just doesn't give a crap! See [Why do we need ANTLR v4?](faq/general.md) and the [preface of the ANTLR v4 book](http://media.pragprog.com/titles/tpantlr2/preface.pdf).
+Hi and welcome to the version 4 release of ANTLR! See [Why do we need ANTLR v4?](faq/general.md) and the [preface of the ANTLR v4 book](http://media.pragprog.com/titles/tpantlr2/preface.pdf).
+
+## Getting started the easy way using antlr4-tools
+
+To play around with ANTLR without having to worry about installing it and the Java needed to execute it, use [antlr4-tools](https://github.com/antlr/antlr4-tools). The only requirement is Python3, which is typically installed on all developer machines on all operating systems. (See below for Windows issue.)
+
+```bash
+$ pip install antlr4-tools
+```
+
+That command creates `antlr4` and `antlr4-parse` executables that, if necessary, will download and install Java 11 plus the latest ANTLR jar:
+
+```bash
+$ antlr4 
+Downloading antlr4-4.11.1-complete.jar
+ANTLR tool needs Java to run; install Java JRE 11 yes/no (default yes)? y
+Installed Java in /Users/parrt/.jre/jdk-11.0.15+10-jre; remove that dir to uninstall
+ANTLR Parser Generator  Version 4.11.1
+ -o ___              specify output directory where all output is generated
+ -lib ___            specify location of grammars, tokens files
+...
+```
+
+Let's play with a simple grammar:
+
+```
+grammar Expr;		
+prog:	expr EOF ;
+expr:	expr ('*'|'/') expr
+    |	expr ('+'|'-') expr
+    |	INT
+    |	'(' expr ')'
+    ;
+NEWLINE : [\r\n]+ -> skip;
+INT     : [0-9]+ ;
+```
+
+### Windows-specific issues
+
+On Windows, the `pip` command doesn't just work---you need to add the `...\local-packages\python38\scripts` dir to your `PATH`, which itself might require a fun reboot.  If you use WSL on Windows, then the pip install will also properly at the scripts directly (if you run from bash shell).
+
+
+1. Go to the Microsoft Store
+2. Search in Microsoft Store for Python
+3. Select the newest version of Python (3.10).
+4. Click the "Get" button. Store installs python and pip at "c:\Users...\AppData\Local\Microsoft\WindowsApps\python.exe" and "c:\Users...\AppData\Local\Microsoft\WindowsApps\pip.exe", respectively. And, it updates the search path immediately with the install.
+5. Open a "cmd" terminal.
+6. You can now type "python" and "pip", and "pip install antlr4-tools". 7. Unfortunately, it does not add that to the search path.
+7. Update the search path to contain `c:\Users...\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p8\LocalCache\local-packages\Python310\Scripts`. You may need to install MSYS2, then do a `find /c/ -name antlr4.exe 2> /dev/null` and enter that path.
+8. Or, you can set up an alias to antlr4.exe on that path.
+
+The good news is that the ANTLR4 Python tool downloads the ANTLR jar in a standard location, and you don't need to do that manually. It's also possible to go in a browser, go to python.org, and download the python package. But, it's likely you will need to update the path for antlr4.exe as before.
+
+### Try parsing with a sample grammar
+
+To parse and get the parse tree in text form, use:
+
+```bash
+$ antlr4-parse Expr.g4 prog -tree
+10+20*30
+^D
+(prog:1 (expr:2 (expr:3 10) + (expr:1 (expr:3 20) * (expr:3 30))) <EOF>)
+```
+(Note: `^D` means control-D and indicates "end of input" on Unix; use `^Z` on Windows.)
+
+Here's how to get the tokens and trace through the parse:
+
+```bash
+$ antlr4-parse Expr.g4 prog -tokens -trace
+10+20*30
+^D
+[@0,0:1='10',<INT>,1:0]
+[@1,2:2='+',<'+'>,1:2]
+[@2,3:4='20',<INT>,1:3]
+[@3,5:5='*',<'*'>,1:5]
+[@4,6:7='30',<INT>,1:6]
+[@5,9:8='<EOF>',<EOF>,2:0]
+enter   prog, LT(1)=10
+enter   expr, LT(1)=10
+consume [@0,0:1='10',<8>,1:0] rule expr
+enter   expr, LT(1)=+
+consume [@1,2:2='+',<3>,1:2] rule expr
+enter   expr, LT(1)=20
+consume [@2,3:4='20',<8>,1:3] rule expr
+enter   expr, LT(1)=*
+consume [@3,5:5='*',<1>,1:5] rule expr
+enter   expr, LT(1)=30
+consume [@4,6:7='30',<8>,1:6] rule expr
+exit    expr, LT(1)=<EOF>
+exit    expr, LT(1)=<EOF>
+exit    expr, LT(1)=<EOF>
+consume [@5,9:8='<EOF>',<-1>,2:0] rule prog
+exit    prog, LT(1)=<EOF>
+```
+
+Here's how to get a visual tree view:
+
+```bash
+$ antlr4-parse Expr.g4 prog -gui
+10+20*30
+^D
+```
+
+The following will pop up in a Java-based GUI window:
+
+<img src="https://github.com/antlr/antlr4-tools/blob/master/images/parse-tree.png?raw=true" width="300">
+
+### Generating parser code
+
+The previous section used a built-in ANTLR interpreter but typically you will ask ANTLR to generate code in the language used by your project (there are about 10 languages to choose from as of 4.11).  Here's how to generate Java code from a grammar:
+
+```bash
+$ antlr4 Expr.g4
+$ ls Expr*.java
+ExprBaseListener.java  ExprLexer.java         ExprListener.java      ExprParser.java
+```
+
+And, here's how to generate C++ code from the same grammar:
+
+```bash
+$ antlr4 -Dlanguage=Cpp Expr.g4
+$ ls Expr*.cpp Expr*.h
+ExprBaseListener.cpp  ExprLexer.cpp         ExprListener.cpp      ExprParser.cpp
+ExprBaseListener.h    ExprLexer.h           ExprListener.h        ExprParser.h
+```
 
 ## Installation
 
-ANTLR is really two things: a tool that translates your grammar to a parser/lexer in Java (or other target language) and the runtime needed by the generated parsers/lexers. Even if you are using the ANTLR Intellij plug-in or ANTLRWorks to run the ANTLR tool, the generated code will still need the runtime library. 
+ANTLR is really two things: a tool written in Java that translates your grammar to a parser/lexer in Java (or other target language) and the runtime library needed by the generated parsers/lexers. Even if you are using the ANTLR Intellij plug-in or ANTLRWorks to run the ANTLR tool, the generated code will still need the runtime library. 
 
 The first thing you should do is probably download and install a development tool plug-in. Even if you only use such tools for editing, they are great. Then, follow the instructions below to get the runtime environment available to your system to run generated parsers/lexers.  In what follows, I talk about antlr-4.11.1-complete.jar, which has the tool and the runtime and any other support libraries (e.g., ANTLR v4 is written in v3).
 

doc/releasing-antlr.md

@@ -279,61 +279,24 @@ zip -r ~/antlr/sites/website-antlr4/download/antlr-javascript-runtime-4.11.1.zip
 
 ### CSharp
 
-**Install the pre-requisites**
+As of writing, you can only release from a Windows box, because Visual Studio for Mac can only build the netstandard2.0 version
 
-You need Mono and `nuget` to be installed. On mac:
+**Install the pre-requisites**
 
-- .NET build tools - can be loaded from [here](https://www.visualstudio.com/downloads/) (I need dotnet 5 and 3.1 versions)
-- nuget - download [nuget.exe](https://www.nuget.org/downloads)
-- dotnet - follow [the instructions here](https://www.microsoft.com/net/core)
+You need 'msbuild' and `nuget` to be installed. 
 
-Alternatively, you can install Visual Studio 2017 and make sure to check boxes with .NET Core SDK.
+**Creating the signed assembly**
 
-You also need to enable .NET Framework 3.5 support in Windows "Programs and Features".
+cd ~/antlr/code/antlr4/runtime/CSharp/src
+dotnet build -c Release Antlr4.csproj
 
-**Creating the signed assembly**
+check that the bin/Release folder contains both the netstandard2.0 and the net45 builds
+the binaries are already signed, but it's worth double checking
 
-From Mac:
+sn -v bin/Release/netstandard2.0/Antlr4.Runtime.Standard.dll
+sn -v bin/Release/net45/Antlr4.Runtime.Standard.dll
 
-```bash
-critter:~ $ cd ~/antlr/code/antlr4/runtime/CSharp/src
-critter:~/antlr/code/antlr4/runtime/CSharp/src $ dotnet build -c Release Antlr4.csproj
-Microsoft (R) Build Engine version 16.7.2+b60ddb6f4 for .NET
-Copyright (C) Microsoft Corporation. All rights reserved.
-
-  Determining projects to restore...
-  Restored /Users/parrt/antlr/code/antlr4/runtime/CSharp/src/Antlr4.csproj (in 340 ms).
-  Antlr4 -> /Users/parrt/antlr/code/antlr4/runtime/CSharp/src/bin/Release/netstandard2.0/Antlr4.Runtime.Standard.dll
-  Successfully created package '/Users/parrt/antlr/code/antlr4/runtime/CSharp/src/bin/Release/Antlr4.Runtime.Standard.4.11.1.0.nupkg'.
-
-Build succeeded.
-    0 Warning(s)
-    0 Error(s)
-
-Time Elapsed 00:00:06.77
-critter:~/antlr/code/antlr4/runtime/CSharp/src $ /Library/Frameworks/Mono.framework/Versions/Current/Commands/sn -R bin/Release/netstandard2.0/Antlr4.Runtime.Standard.dll Antlr4.snk
-Mono StrongName - version 6.12.0.0
-StrongName utility for signing assemblies
-Copyright 2002, 2003 Motus Technologies. Copyright 2004-2008 Novell. BSD licensed.
-
-Assembly bin/Release/netstandard2.0/Antlr4.Runtime.Standard.dll signed.
-critter:~/antlr/code/antlr4/runtime/CSharp/src $ /Library/Frameworks/Mono.framework/Versions/Current/Commands/sn -v bin/Release/netstandard2.0/Antlr4.Runtime.Standard.dll
-Mono StrongName - version 6.12.0.0
-StrongName utility for signing assemblies
-Copyright 2002, 2003 Motus Technologies. Copyright 2004-2008 Novell. BSD licensed.
-
-Assembly bin/Release/netstandard2.0/Antlr4.Runtime.Standard.dll is strongnamed.
-$ tree /Users/parrt/antlr/code/antlr4/runtime/CSharp/src/bin/Release/
-/Users/parrt/antlr/code/antlr4/runtime/CSharp/src/bin/Release/
-├── Antlr4.Runtime.Standard.4.11.1.0.nupkg
-└── netstandard2.0
-    ├── Antlr4.Runtime.Standard.deps.json
-    ├── Antlr4.Runtime.Standard.dll
-    ├── Antlr4.Runtime.Standard.pdb
-    └── Antlr4.Runtime.Standard.xml
-
-1 directory, 5 files
-```
+both should say the dll is valid
 
 **Publishing to NuGet**
 
@@ -346,9 +309,6 @@ Alternately, you can publish from the cmd line. You need to get your NuGet key f
 nuget push Antlr4.Runtime.Standard.<version>.nupkg <your-key> -Source https://www.nuget.org/api/v2/package
 ```
 
-Nuget packages are also accessible as artifacts of [AppVeyor builds](https://ci.appveyor.com/project/parrt/antlr4/build/artifacts). 
-
-
 ### Python
 
 The Python targets get deployed with `setup.py` (Python 2), or `build` and `twine` (Python 3).

doc/swift-target.md

@@ -131,8 +131,9 @@ Add Antlr4 as a dependency to your `Package.swift` file. For more information, p
 
 
 ```swift
-.package(name: "Antlr4", url: "https://github.com/antlr/antlr4", from: "4.11.1"
+.package(url: "https://github.com/antlr/antlr4", from: "4.11.1")
 ```
+
 ## Swift access levels
 
 You may use the `accessLevel` option to control the access levels on generated

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/LeftRecursion/MultipleAlternativesWithCommonLabel_1.txt

@@ -10,8 +10,8 @@ Parser
 grammar T;
 s : e {<writeln("$e.v")>};
 e returns [int v]
-  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
-  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
   | INT{$v = $INT.int;} # anInt
   | '(' e ')'   {$v = $e.v;}     # parens
   | left=e INC  {<ContextRuleFunction(Cast("UnaryContext","$ctx"), "INC()"):Concat(" != null"):Assert()>$v = $left.v + 1;}      # unary

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/LeftRecursion/MultipleAlternativesWithCommonLabel_2.txt

@@ -10,8 +10,8 @@ Parser
 grammar T;
 s : e {<writeln("$e.v")>};
 e returns [int v]
-  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
-  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
   | INT{$v = $INT.int;} # anInt
   | '(' e ')'   {$v = $e.v;}     # parens
   | left=e INC  {<ContextRuleFunction(Cast("UnaryContext","$ctx"), "INC()"):Concat(" != null"):Assert()>$v = $left.v + 1;}      # unary

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/LeftRecursion/MultipleAlternativesWithCommonLabel_3.txt

@@ -10,8 +10,8 @@ Parser
 grammar T;
 s : e {<writeln("$e.v")>};
 e returns [int v]
-  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
-  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
   | INT{$v = $INT.int;} # anInt
   | '(' e ')'   {$v = $e.v;}     # parens
   | left=e INC  {<ContextRuleFunction(Cast("UnaryContext","$ctx"), "INC()"):Concat(" != null"):Assert()>$v = $left.v + 1;}      # unary

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/LeftRecursion/MultipleAlternativesWithCommonLabel_4.txt

@@ -10,8 +10,8 @@ Parser
 grammar T;
 s : e {<writeln("$e.v")>};
 e returns [int v]
-  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
-  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
   | INT{$v = $INT.int;} # anInt
   | '(' e ')'   {$v = $e.v;}     # parens
   | left=e INC  {<ContextRuleFunction(Cast("UnaryContext","$ctx"), "INC()"):Concat(" != null"):Assert()>$v = $left.v + 1;}      # unary

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/LeftRecursion/MultipleAlternativesWithCommonLabel_5.txt

@@ -10,8 +10,8 @@ Parser
 grammar T;
 s : e {<writeln("$e.v")>};
 e returns [int v]
-  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
-  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):ContextMember({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  : e '*' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> * <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
+  | e '+' e     {$v = <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(0)}, {<Result("v")>})> + <Cast("BinaryContext","$ctx"):SubContextLocal({<Production("e")>(1)}, {<Result("v")>})>;}  # binary
   | INT{$v = $INT.int;} # anInt
   | '(' e ')'   {$v = $e.v;}     # parens
   | left=e INC  {<ContextRuleFunction(Cast("UnaryContext","$ctx"), "INC()"):Concat(" != null"):Assert()>$v = $left.v + 1;}      # unary

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/Listeners/Basic.txt

@@ -9,8 +9,8 @@ grammar T;
 
 s
 @after {
-<ContextRuleFunction("$ctx", "r"):ToStringTree():writeln()>
-<ContextRuleFunction("$ctx", "r"):WalkListener()>
+<ContextMember("$ctx", "r"):ToStringTree():writeln()>
+<ContextMember("$ctx", "r"):WalkListener()>
 }
   : r=a ;
 a : INT INT

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/Listeners/LR.txt

@@ -9,8 +9,8 @@ grammar T;
 
 s
 @after {
-<ContextRuleFunction("$ctx", "r"):ToStringTree():writeln()>
-<ContextRuleFunction("$ctx", "r"):WalkListener()>
+<ContextMember("$ctx", "r"):ToStringTree():writeln()>
+<ContextMember("$ctx", "r"):WalkListener()>
 }
    : r=e ;
 e : e op='*' e