Allow deepcopy of fparser tree

.gitignore

@@ -33,6 +33,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *.pyc
 *~
+src/**/*.mod
 *.log
 _build/
 htmlcov/

src/fparser/two/Fortran2003.py

@@ -252,19 +252,22 @@ class Program(BlockBase):  # R201
     use_names = ["Program_Unit"]
 
     @show_result
-    def __new__(cls, string):
+    def __new__(cls, string, _deepcopy=False):
         """Wrapper around base class __new__ to catch an internal NoMatchError
         exception and raise it as an external FortranSyntaxError exception.
 
         :param type cls: the class of object to create
         :param string: (source of) Fortran string to parse
         :type string: :py:class:`FortranReaderBase`
+        :param _deepcopy: Flag to signal whether this class is
+            created by a deep copy
+        :type _deepcopy: bool
         :raises FortranSyntaxError: if the code is not valid Fortran
 
         """
         # pylint: disable=unused-argument
         try:
-            return Base.__new__(cls, string)
+            return Base.__new__(cls, string, _deepcopy=_deepcopy)
         except NoMatchError:
             # At the moment there is no useful information provided by
             # NoMatchError so we pass on an empty string.
@@ -277,6 +280,18 @@ def __new__(cls, string):
             # provides line number information).
             raise FortranSyntaxError(string, excinfo)
 
+    def __getnewargs__(self):
+        """Method to dictate the values passed to the __new__() method upon
+        unpickling. The method must return a pair (args, kwargs) where
+        args is a tuple of positional arguments and kwargs a dictionary
+        of named arguments for constructing the object. Those will be
+        passed to the __new__() method upon unpickling.
+
+        :return: set of arguments for __new__
+        :rtype: set
+        """
+        return (self.string, True)
+
     @staticmethod
     def match(reader):
         """Implements the matching for a Program. Whilst the rule looks like

src/fparser/two/tests/test_parser.py

@@ -84,3 +84,47 @@ class do not affect current calls.
     with pytest.raises(ValueError) as excinfo:
         parser = ParserFactory().create(std="invalid")
         assert "is an invalid standard" in str(excinfo.value)
+
+
+def test_deepcopy():
+    """
+    Test that we can deepcopy a parsed fparser tree.
+    """
+
+    f90_source = """
+program main
+
+  implicit none
+
+end
+"""
+    parser = ParserFactory().create(std="f2008")
+    reader = FortranStringReader(f90_source)
+    ast = parser(reader)
+
+    import copy
+
+    _ = copy.deepcopy(ast)
+
+
+def test_pickle():
+    """
+    Test that we can pickle and unpickle a parsed fparser tree.
+    """
+
+    f90_source = """
+program main
+
+  implicit none
+
+end
+"""
+
+    parser = ParserFactory().create(std="f2008")
+    reader = FortranStringReader(f90_source)
+    ast = parser(reader)
+
+    import pickle
+
+    s = pickle.dumps(ast)
+    _ = pickle.loads(s)

src/fparser/two/utils.py

@@ -409,7 +409,7 @@ def __init__(self, string, parent_cls=None):
         self.parent = None
 
     @show_result
-    def __new__(cls, string, parent_cls=None):
+    def __new__(cls, string, parent_cls=None, _deepcopy=False):
         if parent_cls is None:
             parent_cls = [cls]
         elif cls not in parent_cls:
@@ -418,6 +418,11 @@ def __new__(cls, string, parent_cls=None):
         # Get the class' match method if it has one
         match = getattr(cls, "match", None)
 
+        if _deepcopy:
+            # If this is part of a deep-copy operation (and string is None), simply call
+            # the super method without string
+            return super().__new__(cls)
+
         if (
             isinstance(string, FortranReaderBase)
             and match
@@ -505,6 +510,18 @@ def __new__(cls, string, parent_cls=None):
             errmsg = f"{cls.__name__}: '{string}'"
         raise NoMatchError(errmsg)
 
+    def __getnewargs__(self):
+        """Method to dictate the values passed to the __new__() method upon
+        unpickling. The method must return a pair (args, kwargs) where
+        args is a tuple of positional arguments and kwargs a dictionary
+        of named arguments for constructing the object. Those will be
+        passed to the __new__() method upon unpickling.
+
+        :return: set of arguments for __new__
+        :rtype: set
+        """
+        return (self.string, None, True)
+
     def get_root(self):
         """
         Gets the node at the root of the parse tree to which this node belongs.