Method match

aura/pattern_matching.py:215–248

(
                self,
                node: nodes.NodeType,  # original AST node from the source code
                other: nodes.NodeType  # AST node pattern to match against
        )

            self.pattern = pattern

        def match(
                self,
                node: nodes.NodeType,  # original AST node from the source code
                other: nodes.NodeType  # AST node pattern to match against
        ) -> bool:
            if type(other) == ASTPattern.AnyOf:
                return self._match_any_of(node, other)
            elif node is None:
                return other is None
            elif type(node) == bool:
                if type(other) != bool:
                    return False
                return node is other
            elif type(node) == str:
                if type(other) not in (str, nodes.String):
                    return False
                return node == str(other)
            elif type(node) == dict:
                return self._match_dict(node, other)
            elif type(node) in (list, tuple):
                return self._match_list(node, other)
            elif type(node) == int:
                if type(other) not in (int, nodes.Number):
                    return False
                return node == int(other)
            elif type(node) == float:
                if type(other) != float:
                    return False
                return node == other

            try:
                return node.match(other, self)
            except AttributeError:
                return False

        # Dispatch method for basic python types
        def _match_dict(self, node: dict, other) -> bool: