Static and non-static method overloading

[Timon Gehr]

On 09/27/2011 05:11 PM, Gor Gyolchanyan wrote:
> I have a question about static and non-static methods overloading.
> I have this module:
>
> --------------------------------------------------------------------------------
>
> /**
>    * Dynamic library interfacing module.
>    */
> module dynlib;
>
> public:
>      /**
>        * A lazily loaded cached dynamic library.
>        */
>      class DynLib
>      {
>      public:
>          alias void* Symbol;
>
>          /**
>            * Loads or returns already loaded dynamic library.
>            */
>          static DynLib opIndex(in char[] name)
>          {
>              auto lib = name in _libraries;
>              if(lib)
>                  return *lib;
>              _libraries[name] = new DynLib(name);
>              return DynLib[name];
>          }
>
>          /**
>            * Loads or returns already loaded symbol from this dynamic
> library.
>            */
>          Symbol opIndex(in char[] name)
>          {
>              auto sym = name in _symbols;
>              if(sym)
>                  return *sym;
>              version(Windows)
>                  _symbols[name] = GetProcAddress(_handle, name.toStringz);
>              else version(Posix)
>                  _symbols[name] = dlsym(_handle, name.toStringz);
>              return DynLib[name];
>          }
>
>          bool empty() @property
>          {
>              return _handle is null;
>          }
>
>      private:
>          alias void* Handle;
>
>          static DynLib[string] _libraries;
>          static Symbol[string] _symbols;
>          Handle _handle;
>
>          this(in char[] name)
>          {
>              version(Windows)
>                  _handle = LoadLibraryA(name.toStringz);
>              else version(Posix)
>                  _handle = dlopen(name.toStringz, RTLD_NOW);
>          }
>
>          ~this()
>          {
>              version(Windows)
>                  FreeLibrary(_handle);
>              version(Posix)
>                  dlclose(_handle);
>          }
>
>          unittest
>          {
>              DynLib dl;
>              version(Windows)
>                  dl = DynLib["OpenGL32.dll"];
>              version(Posix)
>                  dl = DynLib["libGL.so"];
>              assert(!dl.empty);
>
>              DynLib.Symbol sym = dl["glClearColor"];
>              assert(sym !is null);
>          }
>      }
>
> private:
>      import std.string: toStringz;
>
>      version(Windows)
>          import core.sys.windows.windows: LoadLibraryA, FreeLibrary,
> GetProcAddress;
>      else version(Posix)
>          import core.sys.posix.dlfcn: dlopen, dlclose, dlsym;
>
> --------------------------------------------------------------------------------
>
> And when i compile this, i get an unexpected error:
>
> --------------------------------------------------------------------------------
>
> dynlib.d(24): Error: function dynlib.DynLib.opIndex called with argument
> types:
>          ((const(char[])))
> matches both:
>          dynlib.DynLib.opIndex(in const(char[]) name)
> and:
>          dynlib.DynLib.opIndex(in const(char[]) name)
> dynlib.d(39): Error: function dynlib.DynLib.opIndex called with argument
> types:
>          ((const(char[])))
> matches both:
>          dynlib.DynLib.opIndex(in const(char[]) name)
> and:
>          dynlib.DynLib.opIndex(in const(char[]) name)
> dynlib.d(39): Error: cannot implicitly convert expression
> (opIndex(name)) of type dynlib.DynLib to void*
>
> --------------------------------------------------------------------------------
>
> My point is: How can this be ambiguous, when i explicitly call the
> static method from the class name, not the object and when i call a
> method from an object, the most obvious choice is the non-static one?
>
> Cheers,
> Gor.
>

There as been some discussion about this issue and afaik Steve has filed 
a bug report. Currently, it is possible to call a static method on a 
class instance.