Making module variables private - module

Question

During the last few years, I have been creating several modules with subroutines that I then use for different projects. I am having problems when I define parameter variables in one of those project-specific files that conflict with a variable name defined within those modules. Is it possible to make those names subroutine-private or module-private?
Here is an example. Suppose I have the following module:
module mymod
implicit none
contains
subroutine test1(x)
real, intent(in) :: x(:)
print *, x**2.0
end subroutine test1
end module mymod
This module is then called by the main program
program main
use mymod
implicit none
real :: y
real,dimension(2,1),parameter :: x = [1.0,2.0]
y = 3.0
call test1(y)
end program main
In this case, given that x in the main program is defined as a parameter with different dimensions to the x in subroutine test1, there will be problems when compiling (shape matching rules violated). Is there any way of making x in module mymod private within the module?
I know an option could be to use "non-common" variable names in my modules or have a list of forbidden names, but that seems complicated at this point (requires editing too many files and lose consistency of notation with books/papers where these procedures are outlined), and would make collaboration with colleagues more difficult.

Answer 1

Two different questions in one:
Why is the example program failing to compile:
This has nothing to do with public or private, or x being defined in the program itself.
It has everything to do with the fact that in the module, x as a parameter is defined as a 1-d array, and in the main program, y is a scalar.
Try it, remove the declaration of x in the main program and it will still fail.
(In fact, the declaration doesn't work like that anyway, you declare x as a 2-d array (shape 2, 1), but then give it a 1-d array. You'd have to do something like:
real, dimension(2, 1), parameter x = reshape([1.0, 2.0], [2, 1])
But to get rid of the error you describe, you either need to change the subroutine interface by removing the (:) behind the real, intent(in) :: x, or change the call to call test1([y]).
What can you do when 2 modules import different variables of the same name:
It would be different if you were to say have this:
module modA
implicit none
real, parameter :: x = 2.0
contains
subroutine subA(k)
real, intent(in) :: k
print *, k*x
end subroutine subA
end module modA
module modB
implicit none
real :: x(3)
end module modB
program progtest
use modA
use modB
implicit none
call subA(x(1))
end program progtest
In this example, it would try to import the variable x from both modules.
Ways to avoid it:
Make one x private:
implicit none
real, parameter, private :: x = 2.0
or
real, parameter :: x = 2.0
private :: x
or
implicit none
private
real, parameter :: x = 2.0
public :: subA
Only import the parts that you need:
program progtest
use modA, only: subA
use modB
implicit none
...
Rename one or both of the x:
use modA
use modB, only: xB => x
...
call subA(xB(1))