I don't understand why the compiler chooses the copy constructor of my `Production` class and has no other candidate functions.
I made a minimal example to demonstrate the error:

```
#include <string>
#include <typeindex>
#include <iostream>

struct DummyProduction {
};

struct Dep {
};

struct Pro {
};

class ModuleBase {
};

template<typename Production = DummyProduction>
class Provider {
public:
  template<typename... Dependencies>
  Provider(ModuleBase& module, Dependencies... args)
  {
    std::cout << "Provider called!" << std::endl;
  }
  Provider(const Provider&) = delete;
};

class TargetController : public ModuleBase,
  public Provider<Pro>,
  public Provider<>
{
public:
  TargetController();
private:
  Dep p;
};

TargetController::TargetController() :
  ModuleBase(),
  Provider<Pro>(*this, &p),
  Provider<>(*this),
  p()
{
}

int main()
{
  TargetController x;
  return 0;
}

```

I tried it with gcc and clang. Here is a link to the non working example: [link](http://ideone.com/ueJJvG).

For the `Provider<Pro>(*this, p)` the right constructor is called. But for the second example `Provider<>(*this)` the compiler tries to call the copy-constructor.

From what I understood from the [Overload resolution](http://en.cppreference.com/w/cpp/language/overload_resolution) page all functions that match the expressions are should get inside the candidate function set. But either the variadic constuctor is not inside the set for the Provider without dependencies or the compiler chooses the copy-constructor in spite of beeing deleted.

Is there a way to avoid this behaviour?