Remove concepts not in antlr4

adsharma · adsharma · commit 0078f83c697d · 2021-08-09T23:31:19.000-07:00
diff --git a/java2python/compiler/__init__.py b/java2python/compiler/__init__.py
@@ -7,15 +7,13 @@
 # instead of using directly referencing items within the subpackage.
 
 from java2python.compiler.block import Module
-from java2python.lang import Lexer, Parser, StringStream, TokenStream, TreeAdaptor
+from java2python.lang import Lexer, Parser, StringStream, TokenStream
 
 
 def buildAST(source):
     """ Returns an AST for the given source. """
     lexer = Lexer(StringStream(source))
     parser = Parser(TokenStream(lexer))
-    adapter = TreeAdaptor(lexer, parser)
-    parser.setTreeAdaptor(adapter)
     scope = parser.javaSource()
     return scope.tree
 
diff --git a/java2python/lang/__init__.py b/java2python/lang/__init__.py
@@ -6,4 +6,4 @@
 
 from java2python.lang.JavaLexer import JavaLexer as Lexer
 from java2python.lang.JavaParser import JavaParser as Parser
-from java2python.lang.base import StringStream, TokenStream, TreeAdaptor, tokens
+from java2python.lang.base import TokenStream, tokens
diff --git a/java2python/lang/base.py b/java2python/lang/base.py
@@ -9,18 +9,6 @@
 # This class is used to create the single `token` instance in this
 # module.  It is used to map between parser tokens and their ids and
 # vice-versa.
-#
-# * `TreeAdaptor`
-#
-# This class is used by `java2python.compiler.tool`, where the
-# `buildAST` function associates an instance of it to a parser.  The
-# `TreeAdaptor` class creates `LocalTree` instances.
-#
-# * `LocalTree`
-#
-# This class provides a slew of extra utility methods that are useful
-# when inspecting and printing tree nodes.
-#
 
 
 # ANTLR notes:
@@ -49,8 +37,7 @@
 
 from io import StringIO
 
-from antlr3 import ANTLRStringStream as StringStream, CommonTokenStream as TokenStream
-from antlr3.tree import CommonTreeAdaptor, CommonTree
+from antlr4 import CommonTokenStream as TokenStream
 
 from java2python.lib import colors
 
@@ -111,159 +98,3 @@ def title(name):
 
 ## sometimes you really do only need one.
 tokens = Tokens()
-
-
-class TreeAdaptor(CommonTreeAdaptor):
-    """ TreeAdaptor -> defered tree node creator (for parsers). """
-
-    def __init__(self, lexer, parser):
-        # CommonTreeAdaptor doesn't need to be __init__'ed
-        self.lexer, self.parser = lexer, parser
-
-    def createWithPayload(self, payload):
-        """ Returns a new tree for the calling parser. """
-        return LocalTree(payload, self.lexer, self.parser)
-
-
-class LocalTree(CommonTree):
-    """ LocalTree -> like CommonTree, but with more stuff. """
-    colorTypeMap = {
-        'CLASS'            : colors.green,
-        'JAVA_SOURCE'      : colors.green,
-        'VOID_METHOD_DECL' : colors.green,
-        'IDENT'            : colors.yellow,
-        'TYPE'             : colors.magenta,
-        'EXPR'             : colors.blue,
-        'TRUE'             : colors.yellow,
-        'FALSE'            : colors.yellow,
-        'NULL'             : colors.yellow,
-    }
-
-    def __init__(self, payload, lexer=None, parser=None):
-        super(LocalTree, self).__init__(payload)
-        self.lexer, self.parser = lexer, parser
-
-    def childrenOfType(self, type):
-        """ Returns a generator yielding children of this tree of the given type. """
-        return (c for c in self.children if c.type==type)
-
-    def colorType(self, tokenType):
-        """ Returns a color suitable for the given token type. """
-        return self.colorTypeMap.get(tokenType, colors.white)(tokenType)
-
-    def colorText(self, tokenType, tokenText):
-        """ Returns a colorized string from the given token type and text. """
-        return self.colorTypeMap.get(tokenType, colors.white)(tokenText)
-
-    def colorComments(self, token):
-        """ Formats, colors, and returns the comment text from the given token. """
-        ttyp = tokens.map.get(token.type)
-        text = token.text.replace('\n', '\\n').replace('\r', '\\r').replace('\t', '\\t')
-        item = '{0} [{1}:{2}] {3}'.format(ttyp, token.start, token.stop, text)
-        yield colors.black(item)
-
-    def dump(self, fd, level=0):
-        """ Writes a debug representation of this tree to the given file. """
-        extras = lambda x, y:x and (x != y)
-        seen, nform = set(), '{0}{1}{2}{3}'
-        def innerDump(root, offset):
-            token, indent = root.token, '    ' * offset
-            start, stop = root.tokenStartIndex, root.tokenStopIndex
-            idxes, ttyp = '', tokens.map.get(token.type, '?')
-            line = token.line
-            if start and stop and start == stop:
-                idxes = 'start={}'.format(start)
-            elif start and stop:
-                idxes = 'start={}, stop={}'.format(start, stop)
-            if line:
-                idxes = 'line={}{}{}'.format(line, ', ' if idxes else '', idxes)
-            idxes = ' [{}]'.format(idxes) if idxes else ''
-            idxes = colors.black(idxes)
-            args = [indent, self.colorType(ttyp), '', idxes, '']
-            if extras(token.text, ttyp):
-                args[2] = ' ' + self.colorText(ttyp, token.text)
-            for com in self.selectComments(start, seen):
-                for line in self.colorComments(com):
-                    print('{0}{1}'.format(indent, line), file=fd)
-            print(nform.format(*args), file=fd)
-            for child in root.getChildren():
-                innerDump(child, offset+1)
-            for com in self.selectComments(root.tokenStopIndex, seen):
-                for line in self.colorComments(com):
-                    print('{0}{1}'.format(indent, line), file=fd)
-        innerDump(self, level)
-
-    def dumps(self, level=0):
-        """ Dump this token to a string. """
-        fd = StringIO()
-        self.dump(fd, level)
-        return fd.getvalue()
-
-    def dupNode(self):
-        """ Called by the parser to create a duplicate of this tree. """
-        get = lambda v:getattr(self, v, None)
-        return LocalTree(self, get('lexer'), get('parser'))
-
-    def findChildren(self, pred=lambda c:True):
-        """ Depth-first search that yields nodes meeting the predicate. """
-        for child in self.children:
-            if pred(child):
-                yield child
-            for sub in child.findChildren(pred):
-                yield sub
-
-    def findChildrenOfType(self, type):
-        """ Depth-first search that yields nodes of the given type. """
-        return self.findChildren(lambda c:c.type==type)
-
-    def firstChild(self, default=None):
-        """ Returns the first child of this tree or the default. """
-        try:
-            return self.children[0]
-        except (IndexError, ):
-            return default
-
-    def firstChildOfType(self, type, default=None):
-        """ Returns the first child of this tree that matches the given type. """
-        for child in self.children:
-            if child.type == type:
-                return child
-        return default
-
-    @property
-    def isJavaSource(self):
-        """ True if this tree is the outer most type. """
-        return self.token.type == tokens.JAVA_SOURCE
-
-    @property
-    def parentType(self):
-        """ Returns the type of the parent tree. """
-        return self.parent.type
-
-    def parents(self, pred=lambda v:True):
-        """ Yield each parent in the family tree. """
-        while self:
-            if pred(self):
-                yield self
-            self = self.parent
-
-    @property
-    def parserTokens(self):
-        """ Returns the sequence of tokens used to create this tree. """
-        return self.parser.input.tokens[self.tokenStartIndex:self.tokenStopIndex]
-
-    def selectComments(self, stop, memo):
-        """ Returns the comment tokens for this tree up to the given index. """
-        pred = lambda k:k.type in tokens.commentTypes and k.index not in memo
-        ctoks = [t for t in self.parser.input.tokens[0:stop] if pred(t)]
-        memo.update(t.index for t in ctoks)
-        return ctoks
-
-    @property
-    def withinExpr(self):
-        """ True if this tree is contained within an expression. """
-        self = getattr(self.parent, 'parent', None) # skip first expr
-        while self:
-            if self.type in (tokens.EXPR, ):
-                return True
-            self = self.parent
