Shadowing of optional function arguments?

Question

I am trying to define two different packages that process some information in a different way. These packages have functions into them with optional arguments. The names of the optional arguments happen to collide and Mathematica is complaining about shadowing of these symbols. Here is an example of my code:

BeginPackage["MyPackage1`"]
Options[f] = {a -> 1, b -> 2};
f[OptionsPattern[]] := {OptionValue[a], OptionValue[b]};
EndPackage[]

BeginPackage["MyPackage2`"]
Options[g] = {a -> 1, b -> 2};
g[OptionsPattern[]] := {OptionValue[a], OptionValue[b]};
EndPackage[]

Mathematica complains:

"Symbol "a" appears in multiple contexts ({"MyPackage2`", "MyPackage1`"}); definitions in context "MyPackage2`" may shadow or be shadowed by other definitions."

Now I try:

Needs["MyPackage1`"]
Needs["MyPackage2`"]
f[a -> 3, b -> 4]
g[a -> 1, b -> 2]
(* {3,4}  {1,2} *)

Thus, the functions work correctly as they are supposed to, but Mathematica is insisting on coloring a and b in red everywhere and that they appear in different contexts.

Is there a way to solve this problem? (without renaming a and b as they represent the same input data in the two packages, would be non-intuitive to change their names).

Answer 1

Guided by Guess who it is comments, I managed to do it. The solution as suggested by his comments is to define a common package say MyCommon` to declare the symbols and both MyPackage1` and MyPackage2` should use Needs[MyCommon`] to get the symbols. Also as he mentioned, this allows for documenting the symbols as well.

Here is my current implementation to solve the problem:

(* Package MyCommon` *)
BeginPackage["MyCommon`"]
If [ Not @ ValueQ[a::usage], a::usage = "This is a" ];
If [ Not @ ValueQ[b::usage], b::usage = "This is b" ];
EndPackage[]

(* Package MyPackage1` *)
BeginPackage["MyPackage1`", "MyCommon`"] (* MyCommon` passed as Needs *)
Options[f] = {a -> 1, b -> 2};
f[OptionsPattern[]] := {OptionValue[a], OptionValue[b]};
EndPackage[]

(* Package MyPackage2` *)
BeginPackage["MyPackage2`", "MyCommon`"] (* MyCommon` passed as Needs *)
Options[g] = {a -> 1, b -> 2};
g[OptionsPattern[]] := {OptionValue[a], OptionValue[b]};
EndPackage[]

Now, testing this implementation:

Needs["MyPackage1`"]
Needs["MyPackage2`"]
f[a -> 3, b -> 4]
g[a -> 1, b -> 2]
(*{3,4} {1,2}*)

which works without any complaints about the shadowing of the optional arguments symbols.