(Closes #313) permit intrinsic shadowing

doc/source/developers_guide.rst

@@ -248,6 +248,7 @@ corresponding dictionary entries are instances of the `SymbolTable`
 class:
 
 .. autoclass:: fparser.two.symbol_table.SymbolTable
+   :members:
 
 The entries in these tables are instances of the named tuple,
 `SymbolTable.Symbol` which currently has the properties:

src/fparser/two/Fortran2003.py

@@ -12333,77 +12333,92 @@
 
         :param str string: the string to match with the pattern rule.
 
-        :return: a tuple of size 2 containing the name of the \
-        intrinsic and its arguments if there is a match, or None if \
-        there is not.
-        :rtype: (:py:class:`fparser.two.Fortran2003.Intrinsic_Name`, \
-        :py:class:`fparser.two.Fortran2003.Actual_Arg_Spec_List`) or \
-        NoneType
-
-        :raises InternalSyntaxError: If the number of arguments \
-        provided does not match the number of arguments expected by \
-        the intrinsic.
+        :return: a tuple of size 2 containing the name of the intrinsic
+            and its arguments if there is a match, or None if there is not.
+        :rtype: Tuple[:py:class:`fparser.two.Fortran2003.Intrinsic_Name`,
+            :py:class:`fparser.two.Fortran2003.Actual_Arg_Spec_List`] | NoneType
+
+        :raises InternalSyntaxError: If the number of arguments provided does
+            not match the number of arguments expected by the intrinsic and
+            there are no wildcard imports that could be bringing a routine
+            (that overrides it) into scope.
 
         """
         result = CallBase.match(Intrinsic_Name, Actual_Arg_Spec_List, string)
-        if result:
-            # There is a match so check the number of args provided
-            # matches the number of args expected by the intrinsic.
-            function_name = str(result[0])
-            function_args = result[1]
+        if not result:
+            return None
 
-            # Check that that this name is not being shadowed (i.e. overridden)
-            # by a symbol in scope at this point.
-            table = SYMBOL_TABLES.current_scope
-            try:
-                table.lookup(function_name)
-                # We found a matching name so refuse to match this intrinsic.
-                return None
-            except (KeyError, AttributeError):
-                # There is either no matching name in the table or we have
-                # no current scoping region.
-                pass
-
-            # This if/else will not be needed once issue #170 has been
-            # addressed.
-            if isinstance(function_args, Actual_Arg_Spec_List):
-                nargs = len(function_args.items)
-            elif function_args is None:
-                nargs = 0
-            else:
-                nargs = 1
+        # There is a match so check the number of args provided
+        # matches the number of args expected by the intrinsic.
+        function_name = str(result[0])
+        function_args = result[1]
+
+        # Check that that this name is not being shadowed (i.e. overridden)
+        # by a symbol in scope at this point.
+        table = SYMBOL_TABLES.current_scope
+        try:
+            table.lookup(function_name)
+            # We found a matching name so refuse to match this intrinsic.
+            return None
+        except (KeyError, AttributeError):
+            # There is either no matching name in the table or we have
+            # no current scoping region.
+            pass
+
+        # This if/else will not be needed once issue #170 has been
+        # addressed.
+        if isinstance(function_args, Actual_Arg_Spec_List):
+            nargs = len(function_args.items)
+        elif function_args is None:
+            nargs = 0
+        else:
+            nargs = 1
+
+        if function_name in Intrinsic_Name.specific_function_names.keys():
+            # If this is a specific function then use its generic
+            # name to test min and max number of arguments.
+            test_name = Intrinsic_Name.specific_function_names[function_name]
+        else:
+            test_name = function_name
+
+        min_nargs = Intrinsic_Name.generic_function_names[test_name]["min"]
+        max_nargs = Intrinsic_Name.generic_function_names[test_name]["max"]
+
+        # None indicates an unlimited number of arguments
+        if max_nargs is None:
+            if nargs < min_nargs:
+                if table and not table.all_symbols_resolved:
+                    # Wrong number of arguments to be an intrinsic so it must
+                    # be a call to a routine being brought into scope from
+                    # elsewhere.
+                    return None
 
-            if function_name in Intrinsic_Name.specific_function_names.keys():
-                # If this is a specific function then use its generic
-                # name to test min and max number of arguments.
-                test_name = Intrinsic_Name.specific_function_names[function_name]
-            else:
-                test_name = function_name
-
-            min_nargs = Intrinsic_Name.generic_function_names[test_name]["min"]
-            max_nargs = Intrinsic_Name.generic_function_names[test_name]["max"]
-
-            if max_nargs is None:
-                if nargs < min_nargs:
-                    # None indicates an unlimited number of arguments
-                    raise InternalSyntaxError(
-                        "Intrinsic '{0}' expects at least {1} args but found "
-                        "{2}.".format(function_name, min_nargs, nargs)
-                    )
-                # The number of arguments is valid. Return here as
-                # further tests will fail due to max_args being
-                # None.
-                return result
-            if min_nargs == max_nargs and nargs != min_nargs:
-                raise InternalSyntaxError(
-                    "Intrinsic '{0}' expects {1} arg(s) but found {2}."
-                    "".format(function_name, min_nargs, nargs)
-                )
-            if min_nargs < max_nargs and (nargs < min_nargs or nargs > max_nargs):
                 raise InternalSyntaxError(
-                    "Intrinsic '{0}' expects between {1} and {2} args but "
-                    "found {3}.".format(function_name, min_nargs, max_nargs, nargs)
+                    "Intrinsic '{0}' expects at least {1} args but found "
+                    "{2}.".format(function_name, min_nargs, nargs)
                 )
+            # The number of arguments is valid. Return here as
+            # further tests will fail due to max_args being
+            # None.
+            return result
+        if min_nargs == max_nargs and nargs != min_nargs:
+            if table and not table.all_symbols_resolved:
+                return None
+            raise InternalSyntaxError(
+                "Intrinsic '{0}' expects {1} arg(s) but found {2}."
+                "".format(function_name, min_nargs, nargs)
+            )
+        if min_nargs < max_nargs and (nargs < min_nargs or nargs > max_nargs):
+            if table and not table.all_symbols_resolved:
+                # Wrong number of arguments to be an intrinsic so it must
+                # be a call to a routine being brought into scope from
+                # elsewhere.
+                return None
+
+            raise InternalSyntaxError(
+                "Intrinsic '{0}' expects between {1} and {2} args but "
+                "found {3}.".format(function_name, min_nargs, max_nargs, nargs)
+            )
         return result