Ambiguous reference to function error when compiling - fortran

Question

So I have a fortran .f90 file (part of the Monte-Carlo tool called SWEEP) that basically contains two main modules for the implementation of a variable length list using two types. The two modules are as follows:
Module LIST_DP_T
Implicit None
Public
Type LIST_DP
Integer :: Count = 0
Double Precision, Pointer :: Items(:)
End Type
Interface Assignment(=)
Module Procedure SetP
End Interface
Interface Operator(+)
Module Procedure Add
Module Procedure AddItem
Module Procedure AddItems
End Interface
Contains
! -------------------------------------------------------
Subroutine Destroy(list)
! DESCRIPTION
! Clears memory associated with a list type.
! ARGUMENTS.
Type(LIST_DP), Intent(INOUT) :: list
! VARIABLES.
Integer :: err = 0
! EXECUTABLE CODE.
list%Count = 0
Deallocate(list%Items, STAT=err)
Nullify(list%Items)
End Subroutine
! -------------------------------------------------------
Subroutine SetP(new, old)
! DESCRIPTION
! Assigns the list of one list type to another
! by passing the list pointer.
! ARGUMENTS.
Type(LIST_DP), Intent(INOUT) :: new
Type(LIST_DP), Intent(IN) :: old
! EXECUTABLE CODE.
new%Count = old%Count
new%Items => old%Items
End Subroutine
! -------------------------------------------------------
Subroutine Copy(new, old)
! DESCRIPTION
! Copies the list of one list type to another.
! ARGUMENTS.
Type(LIST_DP), Intent(INOUT) :: new
Type(LIST_DP), Intent(IN) :: old
! EXECUTABLE CODE.
new%Count = old%Count
new%Items = old%Items
End Subroutine
! -------------------------------------------------------
Function Add(list1, list2) Result (sumlist)
! DESCRIPTION
! Adds together two list and
! returns a new list.
! ARGUMENTS.
Type(LIST_DP), Intent(IN) :: list1
Type(LIST_DP), Intent(IN) :: list2
Type(LIST_DP) :: sumlist
! VARIABLES.
Integer :: err = 0
Double Precision :: items(list1%Count+list2%Count)
! EXECUTABLE CODE.
! Save current list.
If (list1%Count > 0) items(1:list1%Count) = list1%Items
If (list2%Count > 0) items(list1%Count+1:) = list2%Items
! Resize list.
Deallocate(sumlist%Items, STAT=err)
sumlist%Count = list1%Count + list2%Count
Allocate(sumlist%Items(sumlist%Count), STAT=err)
! Assign back the list.
sumlist%Items = items
End Function
! -------------------------------------------------------
Function AddItem(list, item) Result (newlist)
! DESCRIPTION
! Adds a number to the end of the list and
! returns a new list.
! ARGUMENTS.
Type(LIST_DP), Intent(IN) :: list
Double Precision, Intent(IN) :: item
Type(LIST_DP) :: newlist
! VARIABLES.
Integer :: err = 0
Double Precision :: items(list%Count+1)
! EXECUTABLE CODE.
! Save current list.
If (list%Count > 0) items(1:list%Count) = list%Items
items(list%Count+1) = item
! Resize list.
Deallocate(newlist%Items, STAT=err)
newlist%Count = list%Count + 1
Allocate(newlist%Items(newlist%Count), STAT=err)
! Assign back the list.
newlist%Items = items
End Function
! -------------------------------------------------------
Function AddItems(list, items) Result (newlist)
! DESCRIPTION
! Adds some numbers to the end of the list and
! returns a new list.
! ARGUMENTS.
Type(LIST_DP), Intent(IN) :: list
Double Precision, Intent(IN) :: items(:)
Type(LIST_DP) :: newlist
! VARIABLES.
Integer :: err = 0
Double Precision :: allitems(list%Count+Size(items))
! EXECUTABLE CODE.
! Save current list.
If (list%Count > 0) allitems(1:list%Count) = list%Items
allitems(list%Count+1:) = items
! Resize list.
Deallocate(newlist%Items, STAT=err)
newlist%Count = list%Count + Size(items)
Allocate(newlist%Items(newlist%Count), STAT=err)
! Assign back the list.
newlist%Items = allitems
End Function
! -------------------------------------------------------
Double Precision Function SumList(list)
! DESCRIPTION
! Returns the sum of the list items.
Type(LIST_DP), Intent(IN) :: list
SumList = Sum(list%Items)
End Function
End Module
and the other module which is for an integer list:
Module LIST_INT_T
Implicit None
Public
Type LIST_INT
Integer :: Count = 0
Integer, Pointer :: Items(:)
End Type
Interface Assignment(=)
Module Procedure SetP
End Interface
Interface Operator(+)
Module Procedure Add
Module Procedure AddItem
Module Procedure AddItems
End Interface
Contains
! -------------------------------------------------------
Subroutine Destroy(list)
! DESCRIPTION
! Clears memory associated with a list type.
! ARGUMENTS.
Type(LIST_INT), Intent(INOUT) :: list
! VARIABLES.
Integer :: err = 0
! EXECUTABLE CODE.
list%Count = 0
Deallocate(list%Items, STAT=err)
Nullify(list%Items)
End Subroutine
! -------------------------------------------------------
Subroutine SetP(new, old)
! DESCRIPTION
! Assigns the list of one list type to another
! by passing the list pointer.
! ARGUMENTS.
Type(LIST_INT), Intent(INOUT) :: new
Type(LIST_INT), Intent(IN) :: old
! EXECUTABLE CODE.
new%Count = old%Count
new%Items => old%Items
End Subroutine
! -------------------------------------------------------
Subroutine Copy(new, old)
! DESCRIPTION
! Copies the list of one list type to another.
! ARGUMENTS.
Type(LIST_INT), Intent(INOUT) :: new
Type(LIST_INT), Intent(IN) :: old
! EXECUTABLE CODE.
new%Count = old%Count
new%Items = old%Items
End Subroutine
! -------------------------------------------------------
Function Add(list1, list2) Result (sumlist)
! DESCRIPTION
! Adds together two list and
! returns a new list.
! ARGUMENTS.
Type(LIST_INT), Intent(IN) :: list1
Type(LIST_INT), Intent(IN) :: list2
Type(LIST_INT) :: sumlist
! VARIABLES.
Integer :: err = 0
Integer :: items(list1%Count+list2%Count)
! EXECUTABLE CODE.
! Save current list.
If (list1%Count > 0) items(1:list1%Count) = list1%Items
If (list2%Count > 0) items(list1%Count+1:) = list2%Items
! Resize list.
Deallocate(sumlist%Items, STAT=err)
sumlist%Count = list1%Count + list2%Count
Allocate(sumlist%Items(sumlist%Count), STAT=err)
! Assign back the list.
sumlist%Items = items
End Function
! -------------------------------------------------------
Function AddItem(list, item) Result (newlist)
! DESCRIPTION
! Adds a number to the end of the list and
! returns a new list.
! ARGUMENTS.
Type(LIST_INT), Intent(IN) :: list
Integer, Intent(IN) :: item
Type(LIST_INT) :: newlist
! VARIABLES.
Integer :: err = 0
Integer :: items(list%Count+1)
! EXECUTABLE CODE.
! Save current list.
If (list%Count > 0) items(1:list%Count) = list%Items
items(list%Count+1) = item
! Resize list.
Deallocate(newlist%Items, STAT=err)
newlist%Count = list%Count + 1
Allocate(newlist%Items(newlist%Count), STAT=err)
! Assign back the list.
newlist%Items = items
End Function
! -------------------------------------------------------
Function AddItems(list, items) Result (newlist)
! DESCRIPTION
! Adds some numbers to the end of the list and
! returns a new list.
! ARGUMENTS.
Type(LIST_INT), Intent(IN) :: list
Integer, Intent(IN) :: items(:)
Type(LIST_INT) :: newlist
! VARIABLES.
Integer :: err = 0
Integer :: allitems(list%Count+Size(items))
! EXECUTABLE CODE.
! Save current list.
If (list%Count > 0) allitems(1:list%Count) = list%Items
allitems(list%Count+1:) = items
! Resize list.
Deallocate(newlist%Items, STAT=err)
newlist%Count = list%Count + Size(items)
Allocate(newlist%Items(newlist%Count), STAT=err)
! Assign back the list.
newlist%Items = allitems
End Function
! -------------------------------------------------------
Integer Function SumList(list)
! DESCRIPTION
! Returns the sum of the list items.
Type(LIST_INT), Intent(IN) :: list
SumList = Sum(list%Items)
End Function
End Module
and a third module to make things easier when using the modules:
Module LIST_T
Use LIST_DP_T
Use LIST_INT_T
Implicit None
Public
End Module
The module LIST_T is then called from in a different module called Profile_Driver_Input located a different .f90 file (profile_driver_input.f90) as follows:
Module Profile_Driver_Input
Use LIST_T
Use Sweep
Implicit None
Public
Integer, Parameter :: UIN = 102
Integer, Parameter :: MAX_POINTS=1000, MAX_VARS=200
Type Settings
! Control parameters.
Logical :: Solve=.True., PostProcess=.True.
! Input files.
Character(LEN=200) :: MechFile="" ! Particle mechanism file name.
Character(LEN=200) :: ChemFile="" ! Chemistry profile file name.
! Time stepping variables.
Type(LIST_DP) :: Times ! Times between PSL outputs (first entry is start time).
Type(LIST_INT) :: Steps ! Steps between output times.
....
The code then continues to declare more variables and subroutines.
Upon compilation, the following error appears at the end of the Profile_Driver_Input module:
Error: Name 'additem' at (1) is an ambiguous reference to 'additem' from module 'list_dp_t'
Error: Name 'setp' at (1) is an ambiguous reference to 'setp' from module 'list_dp_t'
Error: Name 'setp' at (1) is an ambiguous reference to 'setp' from module 'list_dp_t'
Error: Name 'additem' at (1) is an ambiguous reference to 'additem' from module 'list_dp_t'
Error: Name 'setp' at (1) is an ambiguous reference to 'setp' from module 'list_dp_t'
Error: Name 'setp' at (1) is an ambiguous reference to 'setp' from module 'list_dp_t'
Error: Name 'additem' at (1) is an ambiguous reference to 'additem' from module 'list_dp_t'
Error: Name 'setp' at (1) is an ambiguous reference to 'setp' from module 'list_dp_t'
I cannot seem to figure out how to resolve this issue. Any help/advice would be appreciated.

Answer 1

You have multiple symbols that are named the same way. They come from different modules, but it is still a problem. For example, a subroutine named additem exists in both modules you show.
If you do not actually need to call the subroutines themselves and you only want to call the overloaded operators (+) and assignments (=), you can change the default accessibility from public to private inside the module and only leave public what actually needs to be accessible.
If both additem and destroy and other subroutines will need to be accessible from both modules at the same time, you will have to rename them to be unique. For example: additem_list_int and additem_list_dp.