strumenta / pylasu Goto Github PK

View Code? Open in Web Editor NEW

22.0 5.0 3.0 177 KB

License: Apache License 2.0

Python 95.34% ANTLR 4.27% Shell 0.39%

starlasu

pylasu's People

Contributors

Stargazers

Watchers

Forkers

loradd

pylasu's Issues

Implement assert_asts_are_equal

Introduce the PylasuParser class

It could look similar to this:

class MyListener(ErrorListener):
    issues: list[Issue]
    issue_type: IssueType

    def __init__(self, issues: list[Issue], issue_type: IssueType):
        self.issues = issues
        self.issue_type = issue_type

    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
        self.issues.append(Issue(message=str(msg),
                                 type=self.issue_type, position=Position(start=Point(line=line, column=column),
                                                                         end=Point(line=line, column=column))))

    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
        pass

    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
        pass

    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
        pass


class PylasuParser:

    def __init__(lexer_class, parser_class):
        self.lexer_class= lexer_class
        self.parser_class = parser_class

    def parse(self, code: str) -> Result:
        issues = []

        input = InputStream(code)

        lexer = self.lexer_class(input)
        lexer.removeErrorListeners()
        lexer.addErrorListener(MyListener(issues, IssueType.LEXICAL))

        token_stream = CommonTokenStream(lexer)
        parser = self.parser_class(token_stream)
        parser.removeErrorListeners()
        parser.addErrorListener(MyListener(issues, IssueType.SYNTACTIC))
        parse_tree = parser.root_rule() # I am not sure how we can invoke the root rule through reflection

        ast = parse_tree.to_ast(issues)
        ast.assign_parents()

        return Result(root=ast, issues=issues)

Align model with latest Kolasu 1.5

Symbol Resolution - Add support for case-insensitive symbol lookup

The current Scope class implementation does not support case-insensitive symbol lookup.

JSON Deserialization - Align with new ParsingResult

The current implementation in unserialize_result expects the given JSON to contain an errors field, which is outdated with respect to the current definition of ParsingResult.

Align transformers with latest Kolasu 1.5

Symbol Resolution - Add support for anonymous symbols and type-based lookup

The current Scope implementation does not support symbol storage and lookup for anonymous symbols, i.e. looking up symbols using features other than names. #5

Symbol Resolution

Add basic support for symbol resolution, i.e. Symbol and Scope.

Remove anonymous symbol resolution and simplify scope

See comment in #7.

@dataclass
class Scope:
    symbols: Dict[str, List[Symbol]] = field(default_factory=list)
    parent: Optional['Scope'] = field(default=None)

    def lookup(self, symbol_name: str, symbol_type: type = Symbol) -> Optional[Symbol]:
        return next((symbol for symbol in self.symbols.get(symbol_name, []) if isinstance(symbol, symbol_type)),
                    self.parent.lookup(symbol_name, symbol_type) if self.parent is not None else None)

    def add(self, symbol: Symbol):
        self.symbols[symbol.name] = self.symbols.get(symbol.name, []) + [symbol]

Integrate symbol resolution support in ReferenceByName

The current implementation of ReferenceByName does not support resolving the target. Analogously to what done in Kolasu, we should extend such class, port the resolution logic in tryToResolve and all unit tests.