pforge 1.0.0__py3-none-any.whl

pforge/nodes/BuiltinAllNodes.py

@@ -0,0 +1,116 @@
+#     Copyright 2020, Batakrishna Sahu, mailto:<Batakrishna.Sahu@suiit.ac.in> find license text at end of file
+
+
+"""Node for the calls to the 'all' built-in."""
+
+from pforge.specs import BuiltinParameterSpecs
+
+from .ExpressionBases import ExpressionBuiltinSingleArgBase
+from .ExpressionShapeMixins import ExpressionBoolShapeExactMixin
+from .NodeMakingHelpers import (
+    makeConstantReplacementNode,
+    makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue,
+    wrapExpressionWithNodeSideEffects,
+)
+from .shapes.BuiltinTypeShapes import tshape_str, tshape_unicode
+
+
+class ExpressionBuiltinAll(
+    ExpressionBoolShapeExactMixin, ExpressionBuiltinSingleArgBase
+):
+    """Builtin All Node class.
+
+    Args:
+        ExpressionBase: 'all - expression'
+
+    Returns:
+        Node that represents built-in 'all' call.
+
+    """
+
+    kind = "EXPRESSION_BUILTIN_ALL"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_all_spec
+
+    def computeExpression(self, trace_collection):
+        value = self.subnode_value
+        shape = value.getTypeShape()
+        if shape.hasShapeSlotIter() is False:
+            # An exception is raised.
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue(
+                template="'%s' object is not iterable",
+                operation="all",
+                original_node=value,
+                value_node=value,
+            )
+
+        if shape in (tshape_str, tshape_unicode):
+            return (
+                wrapExpressionWithNodeSideEffects(
+                    new_node=makeConstantReplacementNode(
+                        constant=True, node=self, user_provided=False
+                    ),
+                    old_node=value,
+                ),
+                "new_constant",
+                "Predicted truth value of built-in 'all' string type argument",
+            )
+
+        iteration_handle = value.getIterationHandle()
+
+        if iteration_handle is not None:
+            all_true = iteration_handle.getAllElementTruthValue()
+
+            if all_true is not None:
+                result = wrapExpressionWithNodeSideEffects(
+                    new_node=makeConstantReplacementNode(
+                        constant=all_true, node=self, user_provided=False
+                    ),
+                    old_node=value,
+                )
+
+                return (
+                    result,
+                    "new_constant",
+                    "Predicted truth value of built-in 'all' argument",
+                )
+
+        self.onContentEscapes(trace_collection)
+
+        # All code could be run, note that.
+        trace_collection.onControlFlowEscape(self)
+
+        # All exception may be raised.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        """returns boolean True if try/except/finally is needed else False"""
+        value = self.subnode_value
+
+        if value.mayRaiseException(exception_type):
+            return True
+
+        return not value.getTypeShape().hasShapeSlotIter()
+
+
+#     Part of "Pforge", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the GNU Affero General Public License, Version 3 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        https://www.gnu.org/licenses/agpl-3.0.txt
+#
+#     See also: "Pforge Runtime Library Exception, Version 1.0" in file
+#     "LICENSE-RUNTIME.txt" for additional permissions granted under Section 7.
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

pforge/nodes/BuiltinAnyNodes.py

@@ -0,0 +1,125 @@
+#     Copyright 2020, Batakrishna Sahu, mailto:<Batakrishna.Sahu@suiit.ac.in> find license text at end of file
+
+
+"""Node for the calls to the 'any' built-in."""
+
+from pforge.specs import BuiltinParameterSpecs
+
+from .ExpressionBases import ExpressionBuiltinSingleArgBase
+from .ExpressionShapeMixins import ExpressionBoolShapeExactMixin
+from .NodeMakingHelpers import (
+    makeConstantReplacementNode,
+    makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue,
+    wrapExpressionWithNodeSideEffects,
+)
+
+
+class ExpressionBuiltinAny(
+    ExpressionBoolShapeExactMixin, ExpressionBuiltinSingleArgBase
+):
+    """Builtin Any Node class.
+
+    Node that represents built-in 'any' call.
+
+    """
+
+    kind = "EXPRESSION_BUILTIN_ANY"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_any_spec
+
+    def computeExpression(self, trace_collection):
+        value = self.subnode_value
+        shape = value.getTypeShape()
+        if shape.hasShapeSlotIter() is False:
+            # An exception is raised.
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue(
+                template="'%s' object is not iterable",
+                operation="any",
+                original_node=value,
+                value_node=value,
+            )
+
+        iteration_handle = value.getIterationHandle()
+
+        if iteration_handle is not None:
+            all_false = True
+            count = 0
+            while True:
+                truth_value = iteration_handle.getNextValueTruth()
+                if truth_value is StopIteration:
+                    break
+                if count > 256:
+                    all_false = False
+                    break
+
+                if truth_value is True:
+                    result = wrapExpressionWithNodeSideEffects(
+                        new_node=makeConstantReplacementNode(
+                            constant=True, node=self, user_provided=False
+                        ),
+                        old_node=value,
+                    )
+
+                    return (
+                        result,
+                        "new_constant",
+                        "Predicted truth value of built-in any argument",
+                    )
+                elif truth_value is None:
+                    all_false = False
+
+                count += 1
+
+            if all_false is True:
+                result = wrapExpressionWithNodeSideEffects(
+                    new_node=makeConstantReplacementNode(
+                        constant=False, node=self, user_provided=False
+                    ),
+                    old_node=value,
+                )
+
+                return (
+                    result,
+                    "new_constant",
+                    "Predicted truth value of built-in any argument",
+                )
+
+        self.onContentEscapes(trace_collection)
+
+        # Any code could be run, note that.
+        trace_collection.onControlFlowEscape(self)
+
+        # Any exception may be raised.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        """returns boolean True if exception is raised else False"""
+        value = self.subnode_value
+
+        if value.mayRaiseException(exception_type):
+            return True
+
+        return not value.getTypeShape().hasShapeSlotIter()
+
+
+#     Part of "Pforge", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the GNU Affero General Public License, Version 3 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        https://www.gnu.org/licenses/agpl-3.0.txt
+#
+#     See also: "Pforge Runtime Library Exception, Version 1.0" in file
+#     "LICENSE-RUNTIME.txt" for additional permissions granted under Section 7.
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

pforge/nodes/BuiltinComplexNodes.py

@@ -0,0 +1,92 @@
+#     Copyright 2026, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+"""Node for the calls to the 'complex' built-in."""
+
+from pforge.specs import BuiltinParameterSpecs
+
+from .ChildrenHavingMixins import (
+    ChildHavingValueMixin,
+    ChildrenHavingRealOptionalImagMixin,
+)
+from .ExpressionBases import (
+    ExpressionBase,
+    ExpressionSpecBasedComputationMixin,
+)
+from .ExpressionShapeMixins import ExpressionComplexShapeExactMixin
+
+
+class ExpressionBuiltinComplex1(
+    ExpressionComplexShapeExactMixin, ChildHavingValueMixin, ExpressionBase
+):
+    kind = "EXPRESSION_BUILTIN_COMPLEX1"
+
+    named_children = ("value",)
+
+    @staticmethod
+    def isExpressionBuiltinCall():
+        return True
+
+    def __init__(self, value, source_ref):
+        ChildHavingValueMixin.__init__(self, value=value)
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def computeExpression(self, trace_collection):
+        value = self.subnode_value
+
+        return value.computeExpressionComplex(
+            complex_node=self, trace_collection=trace_collection
+        )
+
+
+class ExpressionBuiltinComplex2(
+    ExpressionSpecBasedComputationMixin,
+    ExpressionComplexShapeExactMixin,
+    ChildrenHavingRealOptionalImagMixin,
+    ExpressionBase,
+):
+    kind = "EXPRESSION_BUILTIN_COMPLEX2"
+
+    named_children = ("real|optional", "imag")
+
+    @staticmethod
+    def isExpressionBuiltinCall():
+        return True
+
+    builtin_spec = BuiltinParameterSpecs.builtin_complex_spec
+
+    def __init__(self, real, imag, source_ref):
+        ChildrenHavingRealOptionalImagMixin.__init__(
+            self,
+            real=real,
+            imag=imag,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def computeExpression(self, trace_collection):
+        given_values = self.subnode_real, self.subnode_imag
+
+        return self.computeBuiltinSpec(
+            trace_collection=trace_collection, given_values=given_values
+        )
+
+
+#     Part of "Pforge", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the GNU Affero General Public License, Version 3 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        https://www.gnu.org/licenses/agpl-3.0.txt
+#
+#     See also: "Pforge Runtime Library Exception, Version 1.0" in file
+#     "LICENSE-RUNTIME.txt" for additional permissions granted under Section 7.
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

pforge/nodes/BuiltinDecodingNodes.py

@@ -0,0 +1,55 @@
+#     Copyright 2026, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+"""Built-in ord/chr nodes
+
+These are good for optimizations, as they give a very well known result. In the case of
+'chr', it's one of 256 strings, and in case of 'ord' it's one of 256 numbers, so these can
+answer quite a few questions at compile time.
+
+"""
+
+from pforge.specs import BuiltinParameterSpecs
+
+from .ExpressionBases import ExpressionBuiltinSingleArgBase
+
+
+class ExpressionBuiltinOrd(ExpressionBuiltinSingleArgBase):
+    kind = "EXPRESSION_BUILTIN_ORD"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_ord_spec
+
+    @staticmethod
+    def isKnownToBeIterable(count):
+        return False
+
+
+class ExpressionBuiltinChr(ExpressionBuiltinSingleArgBase):
+    kind = "EXPRESSION_BUILTIN_CHR"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_chr_spec
+
+    def isKnownToBeIterable(self, count):
+        if self.mayRaiseException(BaseException):
+            return None
+
+        return count is None or count == 1
+
+
+#     Part of "Pforge", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the GNU Affero General Public License, Version 3 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        https://www.gnu.org/licenses/agpl-3.0.txt
+#
+#     See also: "Pforge Runtime Library Exception, Version 1.0" in file
+#     "LICENSE-RUNTIME.txt" for additional permissions granted under Section 7.
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

pforge/nodes/BuiltinDecoratorNodes.py

@@ -0,0 +1,92 @@
+#     Copyright 2026, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+"""Built-in staticmethod/classmethod nodes
+
+These are good for optimizations, as they give a very well known result, changing
+only the way a class member is being called. Being able to avoid going through a
+C call to the built-ins resulting wrapper, will speed up things.
+"""
+
+from .ExpressionBasesGenerated import (
+    ExpressionBuiltinClassmethodBase,
+    ExpressionBuiltinStaticmethodBase,
+)
+from .shapes.BuiltinTypeShapes import tshape_classmethod, tshape_staticmethod
+
+
+class BuiltinStaticmethodClassmethodMixin(object):
+    __slots__ = ()
+
+    @staticmethod
+    def isExpressionBuiltinCall():
+        return True
+
+    # There is nothing to compute for it as a value.
+    auto_compute_handling = "final,no_raise"
+
+    # TODO: Make it part of auto-compute through a the shape provided.
+    @staticmethod
+    def isKnownToBeIterable(count):
+        # pylint: disable=unused-argument
+        return False
+
+    @staticmethod
+    def isKnownToBeHashable():
+        return True
+
+    # TODO: should be automatic due to final
+    def mayRaiseException(self, exception_type):
+        return self.subnode_value.mayRaiseException(exception_type)
+
+    # TODO: should be a auto_compute property.
+    def mayHaveSideEffect(self):
+        return self.subnode_value.mayHaveSideEffect()
+
+    def extractSideEffects(self):
+        return self.subnode_value.extractSideEffects()
+
+
+class ExpressionBuiltinStaticmethod(
+    BuiltinStaticmethodClassmethodMixin, ExpressionBuiltinStaticmethodBase
+):
+    kind = "EXPRESSION_BUILTIN_STATICMETHOD"
+
+    # TODO: Allow these to be in class classes instead.
+    named_children = ("value",)
+
+    @staticmethod
+    def getTypeShape():
+        return tshape_staticmethod
+
+
+class ExpressionBuiltinClassmethod(
+    BuiltinStaticmethodClassmethodMixin, ExpressionBuiltinClassmethodBase
+):
+    kind = "EXPRESSION_BUILTIN_CLASSMETHOD"
+
+    # TODO: Allow these to be in mixin classes instead.
+    named_children = ("value",)
+
+    @staticmethod
+    def getTypeShape():
+        return tshape_classmethod
+
+
+#     Part of "Pforge", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the GNU Affero General Public License, Version 3 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        https://www.gnu.org/licenses/agpl-3.0.txt
+#
+#     See also: "Pforge Runtime Library Exception, Version 1.0" in file
+#     "LICENSE-RUNTIME.txt" for additional permissions granted under Section 7.
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.