M-x compile gcc ...

默认情况下,compile不会绑定到任何键,但您可以执行以下操作：

(add-hook 'c-mode-common-hook 
          (lambda () (define-key c-mode-base-map (kbd "C-c C-l") 'compile))))

人们在Emacs Wiki上编写了很多软件包.查看SmartCompile,CompileCommand和类别Programmer Utils.

使用M-x编译…而不仅仅是在“终端”中运行它的好处是你得到C-x`(又名下一个错误),它将跳转到导致错误命令的文件和行.还有命令M-x重新编译,它可以满足你的期望.当然,与所有Emacs命令一样,compile命令保留编译调用的历史记录,您可以使用M-p和M-n查看历史记录.

DataContext = UserVM;
btnAdd.DataContext = this;

这是我绑定按钮的方式 – 它的工作原理.

<Button Command="{Binding Add}" Content="Add user" />

现在,我想为该按钮添加KeyGesture,但我无法为InputBindings设置DataContext,并且编译器无法在UsersVM类中找到此Add命令.

<UsersView.InputBindings>
    <KeyBinding Key="F10" Command="{Binding Add}" />
</UsersView.InputBindings>

<Window
   x:xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:myviewmodels="clr-namespace:MVVMExample"
   Title="MainWindow"
   x:Name="MyMainWindow"
   Height="350"
   Width="525">

请注意,我设置了Window的x.Name.然后在我的KeyBinding中,我这样做了……

<Window.InputBindings>

    <KeyBinding
        Key="F10"
        Command="{Binding ElementName=MyMainWindow,Path=DataContext.AddPersonCommand}" />

</Window.InputBindings>

AddPersonCommand是我的viewmodel的ICommand.

@Override
        public MapBinderBinding<?> visit(
                MapBinderBinding<? extends Object> mapBinder) {
            if (mapBinder.getValueTypeLiteral().getRawType().isAssignableFrom(ComponentFactory.class)) {
                System.out.println(mapBinder.getValueTypeLiteral());

                for (Entry<?,Binding<?>> entry : mapBinder.getEntries()) {
                    ComponentFactory<?> factory = (ComponentFactory<?>) entry.getValue().getProvider().get();
                    System.out.println(String.format("  for type='%s' use class '%s' with properties: ",entry.getKey(),factory.getRawType().getSimpleName()));

                    for (Entry<String,PropertyInfo> propEntry : factory.getProperties().entrySet()) {
                        PropertyInfo prop = propEntry.getValue();
                        String   name = propEntry.getKey();

//                        System.out.println(String.format("    %-20s %-10s %-10s",name,prop.getType().getSimpleName(),prop.isDynamic() ? "(dynamic)" : ""));
                    }
                }
            }
            return mapBinder;        
        }

@SuppressWarnings("rawtypes")
public void testGetEntries() {
  List<com.google.inject.spi.Element> elements =
      Elements.getElements(new MapBinderWithTwoentriesModule());

  // Get the MapBinderBinding
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Execute the call to getEntries
  List<Map.Entry<?,Binding<?>>> mapEntries = mapBinderBinding.getEntries(elements);

  // Assert on the results
  Map.Entry<?,Binding<?>> firstEntry = mapEntries.get(0);
  assertEquals("keyOne",firstEntry.getKey());
  Binding<?> firstBinding = firstEntry.getValue();
  assertEquals("valueOne",((InstanceBinding) firstBinding).getInstance());

  Map.Entry<?,Binding<?>> secondEntry = mapEntries.get(1);
  assertEquals("keyTwo",secondEntry.getKey());
  Binding<?> secondBinding = secondEntry.getValue();
  assertEquals("valueTwo",((InstanceBinding) secondBinding).getInstance());
}

/**
 * Given an {@link Iterable} of elements,return the one that is a {@link MapBinderBinding},or
 * {@code null} if it cannot be found.
 */
private static MapBinderBinding<?> getMapBinderBinding(
    Iterable<com.google.inject.spi.Element> elements) {
  final Collector collector = new Collector();
  for (com.google.inject.spi.Element element : elements) {
    element.acceptVisitor(
        new DefaultElementVisitor<Void>() {
          @Override
          public <T> Void visit(Binding<T> binding) {
            binding.acceptTargetVisitor(collector);
            return null;
          }
        });
  }
  return collector.mapbinding;
}

public void testTwoMapBindersAredistinct() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              MapBinder.newMapBinder(binder(),String.class,String.class)
                  .addBinding("A")
                  .toInstance("a");

              MapBinder.newMapBinder(binder(),Integer.class,String.class)
                  .addBinding(1)
                  .toInstance("b");
            }
          });
  Collector collector = new Collector();
  Binding<Map<String,String>> map1 = injector.getBinding(Key.get(mapOfString));
  map1.acceptTargetVisitor(collector);
  assertNotNull(collector.mapbinding);
  MapBinderBinding<?> map1Binding = collector.mapbinding;

  Binding<Map<Integer,String>> map2 = injector.getBinding(Key.get(mapOfIntString));
  map2.acceptTargetVisitor(collector);
  assertNotNull(collector.mapbinding);
  MapBinderBinding<?> map2Binding = collector.mapbinding;

  List<Binding<String>> bindings = injector.findBindingsByType(stringType);
  assertEquals("should have two elements: " + bindings,2,bindings.size());
  Binding<String> a = bindings.get(0);
  Binding<String> b = bindings.get(1);
  assertEquals("a",((InstanceBinding<String>) a).getInstance());
  assertEquals("b",((InstanceBinding<String>) b).getInstance());

  // Make sure the correct elements belong to their own sets.
  assertTrue(map1Binding.containsElement(a));
  assertFalse(map1Binding.containsElement(b));

  assertFalse(map2Binding.containsElement(a));
  assertTrue(map2Binding.containsElement(b));
}

@SuppressWarnings("rawtypes")
public void testGetEntriesWithDuplicateKeys() {
  // Set up the module
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          MapBinder<String,String> mapBinder =
              MapBinder.newMapBinder(binder(),String.class);
          mapBinder.addBinding("A").toInstance("a1");
          mapBinder.addBinding("A").toInstance("a2");
          mapBinder.permitDuplicates();
        }
      };

  // Get the MapBinderBinding
  List<com.google.inject.spi.Element> elements = Elements.getElements(module);
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Execute the call to getEntries
  List<Map.Entry<?,Binding<?>> firstEntry = mapEntries.get(0);
  assertEquals("A",firstEntry.getKey());
  Binding<?> firstBinding = firstEntry.getValue();
  assertEquals("a1",Binding<?>> secondEntry = mapEntries.get(1);
  assertEquals("A",secondEntry.getKey());
  Binding<?> secondBinding = secondEntry.getValue();
  assertEquals("a2",((InstanceBinding) secondBinding).getInstance());
}

@SuppressWarnings("rawtypes")
public void testGetEntriesWithDuplicateValues() {
  // Set up the module
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          MapBinder<String,String.class);
          mapBinder.addBinding("A").toInstance("a");
          mapBinder.addBinding("A").toInstance("a");
        }
      };

  // Get the MapBinderBinding
  List<com.google.inject.spi.Element> elements = Elements.getElements(module);
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Execute the call to getEntries
  List<Map.Entry<?,firstEntry.getKey());
  Binding<?> firstBinding = firstEntry.getValue();
  assertEquals("a",secondEntry.getKey());
  Binding<?> secondBinding = secondEntry.getValue();
  assertEquals("a",((InstanceBinding) secondBinding).getInstance());
}

@SuppressWarnings("rawtypes")
public void testGetEntriesMissingProviderMapEntry() {
  List<com.google.inject.spi.Element> elements =
      Lists.newArrayList(Elements.getElements(new MapBinderWithTwoentriesModule()));

  // Get the MapBinderBinding
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Remove the ProviderMapEntry for "a" from the elements
  com.google.inject.spi.Element providerMapEntryForA = getProviderMapEntry("keyOne",elements);
  boolean removeSuccessful = elements.remove(providerMapEntryForA);
  assertTrue(removeSuccessful);

  // Execute the call to getEntries,we expect it to fail
  try {
    mapBinderBinding.getEntries(elements);
    fail();
  } catch (IllegalArgumentException expected) {
    assertContains(
        expected.getMessage(),"Expected a 1:1 mapping from map keys to values.","Found these Bindings that were missing an associated entry:","java.lang.String","bound at:","MapBinderWithTwoentriesModule");
  }
}

@SuppressWarnings("rawtypes")
public void testGetEntriesMissingBindingForValue() {
  List<com.google.inject.spi.Element> elements =
      Lists.newArrayList(Elements.getElements(new MapBinderWithTwoentriesModule()));

  // Get the MapBinderBinding
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Remove the ProviderMapEntry for "a" from the elements
  com.google.inject.spi.Element bindingForA = getInstanceBindingForValue("valueOne",elements);
  boolean removeSuccessful = elements.remove(bindingForA);
  assertTrue(removeSuccessful);

  // Execute the call to getEntries,"Found these map keys without a corresponding value:","keyOne","MapBinderWithTwoentriesModule");
  }
}

@Override
public MapBinderBinding<?> visit(
        MultibinderBinding<? extends Object> multibinding) {
    // Todo Auto-generated method stub
    return null;
}

@Override
public MapBinderBinding<?> visit(
        OptionalBinderBinding<? extends Object> optionalbinding) {
    // Todo Auto-generated method stub
    return null;
}

@Override
public Object visit(MapBinderBinding<? extends Object> mapbinding) {
  this.mapbinding = mapbinding;
  return null;
}

@Override
public Object visit(MapBinderBinding<? extends T> mapbinding) {
  return mapbinding;
}

@Override
public Set<ResolvedBinding<?>> visit(MapBinderBinding<?> mapbinding) {
  return resolveMultiDependencies(Functional.funPairs(mapbinding.getEntries()).values());
}

private static String instantiation(Binding<?> binding) {
  if (binding instanceof InstanceBinding<?>) {
    return instanceLiteral((InstanceBinding<?>) binding);
  } else if (binding instanceof ProviderKeyBinding<?>) {
    return providerCall(((ProviderKeyBinding<?>) binding).getProviderKey()) + ".get()";
  } else if (binding instanceof LinkedKeyBinding<?>) {
    return providerCall(((LinkedKeyBinding<?>) binding).getLinkedKey());
  } else if (binding instanceof ConstructorBinding<?>) {
    return constructorCall((ConstructorBinding<?>) binding);
  } else if (binding instanceof ProviderBinding<?>) {
    return provider((ProviderBinding<?>) binding);
  } else if (binding instanceof ProviderInstanceBinding<?>) {
    return instantiation((ProviderInstanceBinding<?>) binding);
  } else {
    throw new DeguicifierException();
  }
}

public static <T> Optional<TypeLiteral<? extends T>> targettype(Injector injector,Binding<T> binding) {
    if(binding instanceof UntargettedBinding) {
        return Optional.of(binding.getKey().getTypeLiteral());
    } else if(binding instanceof ConstructorBinding) {
        return Optional.of((TypeLiteral<? extends T>) ((ConstructorBinding) binding).getConstructor().getDeclaringType());
    } else if(binding instanceof InstanceBinding) {
        return Optional.of(TypeLiteral.get((Class<T>) ((InstanceBinding) binding).getInstance().getClass()));
    } else if(binding instanceof LinkedKeyBinding) {
        return targettype(injector,injector.getBinding(((LinkedKeyBinding) binding).getLinkedKey()));
    } else if(binding instanceof ExposedBinding) {
        return targettype(((ExposedBinding) binding).getPrivateElements().getInjector(),binding.getKey());
    }
    return Optional.empty();
}

@Override
public <T> Collection<T> getBeansOfType(Class<T> clazz)
{
    Injector injector = ensureInjector();
    List<T> beans = new ArrayList<T>();
    Map<Key<?>,Binding<?>> bindings = injector.getBindings();
    for( Binding<?> binding : bindings.values() )
    {
        Key<?> actualKey = null;
        if( binding instanceof UntargettedBinding || binding instanceof ConstructorBinding )
        {
            actualKey = binding.getKey();
        }
        else if( binding instanceof LinkedKeyBinding )
        {
            actualKey = ((LinkedKeyBinding<?>) binding).getLinkedKey();
        }
        else if( binding instanceof ProviderBinding )
        {
            actualKey = ((ProviderBinding<?>) binding).getProvidedKey();
        }
        if( actualKey != null && clazz.isAssignableFrom(actualKey.getTypeLiteral().getRawType()) )
        {
            beans.add(clazz.cast(binding.getProvider().get()));
        }
    }
    return beans;
}

@Test
public void binds_linked_key() {
  given(module = new AbstractModule() {
    @Override
    protected void configure() {
      bind(Interface.class).to(Implementation.class);
    }
  });
  given(injector = Guice.createInjector(module));
  when(injector.getBinding(Interface.class));
  thenReturned(instanceOf(LinkedKeyBinding.class));
}

/**
 * Visitor for {@link LinkedKeyBinding}. This is the standard {@link Binding} you get from
 * binding an interface class to an implementation class. We draw a {@link BindingEdge} from the
 * interface node to the node of the implementing class.
 */
@Override
public Collection<Edge> visit(LinkedKeyBinding<?> binding) {
  return ImmutableList.<Edge>of(
      new BindingEdge(
          NodeId.newTypeId(binding.getKey()),NodeId.newTypeId(binding.getLinkedKey()),BindingEdge.Type.norMAL));
}

public void testVisitLinkedKey() {
  Binding<?> binding = getBinding(Key.get(Interface.class),new LinkedKeyModule());
  Collection<Key<?>> dependencies = visitor.visit((LinkedKeyBinding<?>) binding);

  // Dependency should be to the class this interface is bound to.
  assertDependencies(dependencies,Key.get(ConstructedClass.class));
}

@Override
public String toString() {
  return MoreObjects.toStringHelper(LinkedKeyBinding.class)
      .add("key",getKey())
      .add("source",getSource())
      .add("scope",getscoping())
      .add("target",targetKey)
      .toString();
}

private static boolean matches(Binding<?> item,BindResult<?> result) {
  switch (result.type) {
    case INSTANCE:
      if (item instanceof InstanceBinding
          && ((InstanceBinding) item).getInstance().equals(result.instance)) {
        return true;
      }
      break;
    case LINKED:
      if (item instanceof LinkedKeyBinding
          && ((LinkedKeyBinding) item).getLinkedKey().equals(result.key)) {
        return true;
      }
      break;
    case PROVIDER_INSTANCE:
      if (item instanceof ProviderInstanceBinding
          && Objects.equal(
              ((ProviderInstanceBinding) item).getUserSuppliedProvider().get(),result.instance)) {
        return true;
      }
      break;
    case PROVIDER_KEY:
      if (item instanceof ProviderKeyBinding
          && ((ProviderKeyBinding) item).getProviderKey().equals(result.key)) {
        return true;
      }
      break;
  }
  return false;
}

public void testVisitLinkedKey() {
  Binding<?> binding = getBinding(Key.get(Interface.class),Key.get(ConstructedClass.class));
}

private static boolean matches(Binding<?> item,BindResult<?> result) {
  switch (result.type) {
  case INSTANCE:
    if (item instanceof InstanceBinding
        && ((InstanceBinding) item).getInstance().equals(result.instance)) {
      return true;
    }
    break;
  case LINKED:
    if (item instanceof LinkedKeyBinding
        && ((LinkedKeyBinding) item).getLinkedKey().equals(result.key)) {
      return true;
    }
    break;
  case PROVIDER_INSTANCE:
    if (item instanceof ProviderInstanceBinding
        && Objects.equal(((ProviderInstanceBinding) item).getUserSuppliedProvider().get(),result.instance)) {
      return true;
    }
    break;
  case PROVIDER_KEY:
    if (item instanceof ProviderKeyBinding
        && ((ProviderKeyBinding) item).getProviderKey().equals(result.key)) {
      return true;
    }
    break;
  }
  return false;
}

@Override public String toString() {
  return Objects.toStringHelper(LinkedKeyBinding.class)
      .add("key",targetKey)
      .toString();
}

public void testVisitLinkedKey() {
  Binding<?> binding = getBinding(Key.get(Interface.class),Key.get(ConstructedClass.class));
}

@Override public String toString() {
  return Objects.toStringHelper(LinkedKeyBinding.class)
      .add("key",targetKey)
      .toString();
}

@Override
public Optional<TypeLiteral<?>> visit(LinkedKeyBinding<?> binding) {
    // Delegate to the binding for the target type
    return injector.getBinding(binding.getLinkedKey()).acceptTargetVisitor(this);
}

@Override
public Object visit(LinkedKeyBinding<? extends T> linkedKeyBinding) {
    requireKey(linkedKeyBinding.getLinkedKey());
    return super.visit(linkedKeyBinding);
}

@Override
public Void visit(LinkedKeyBinding<? extends T> binding) {
    scope(binding,rebind(binding).to(binding.getLinkedKey()));
    return null;
}

@Override
public Void visit(LinkedKeyBinding<? extends Object> linkedKeyBinding)
{
    analyzeImplementation(linkedKeyBinding.getLinkedKey().getTypeLiteral(),false);
    return null;
}

public Void visit(LinkedKeyBinding<? extends T> linkedKeyBinding) {
  Context context = Context.forElement(linkedKeyBinding);
  bindingsCollection.addBinding(targetKey,bindingFactory.getBindClassBinding(linkedKeyBinding.getLinkedKey(),targetKey,context));
  return null;
}

@Override
public Collection<Key<?>> visit(LinkedKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getLinkedKey());
}

@Override
public Indexer.IndexedBinding visit(LinkedKeyBinding<? extends Object> binding) {
  return new Indexer.IndexedBinding(
      binding,BindingType.LINKED_KEY,scope(binding),binding.getLinkedKey());
}

@Override
public ResolvedBinding<T> visit(LinkedKeyBinding<? extends T> linkedKeyBinding) {
  return traverse(linkedKeyBinding.getLinkedKey());
}

@Override public Collection<Key<?>> visit(LinkedKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getLinkedKey());
}

/**
 * Visitor for {@link LinkedKeyBinding}. This is the standard {@link Binding} you get from
 * binding an interface class to an implementation class. We  draw a {@link BindingEdge} from
 * the interface node to the node of the implementing class.
 */
@Override public Collection<Edge> visit(LinkedKeyBinding<?> binding) {
  return ImmutableList.<Edge>of(new BindingEdge(NodeId.newTypeId(binding.getKey()),BindingEdge.Type.norMAL));
}

@Override public Collection<Key<?>> visit(LinkedKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getLinkedKey());
}

/**
 * Visitor for {@link LinkedKeyBinding}. This is the standard {@link Binding} you get from
 * binding an interface class to an implementation class. We  draw a {@link BindingEdge} from
 * the interface node to the node of the implementing class.
 */
@Override public Collection<Edge> visit(LinkedKeyBinding<?> binding) {
  return ImmutableList.<Edge>of(new BindingEdge(NodeId.newTypeId(binding.getKey()),BindingEdge.Type.norMAL));
}

@SuppressWarnings("unchecked")
private static <T> void setInjectorTest(Key<T> setKey,TypeLiteral<?> elementType,Iterable<? extends Module> modules,boolean allowDuplicates,int otherMultibindings,BindResult... results) {
  Injector injector = Guice.createInjector(modules);
  Visitor<T> visitor = new Visitor<T>();
  Binding<T> binding = injector.getBinding(setKey);
  MultibinderBinding<T> multibinder = (MultibinderBinding<T>)binding.acceptTargetVisitor(visitor);
  assertNotNull(multibinder);
  assertEquals(elementType,multibinder.getElementTypeLiteral());
  assertEquals(allowDuplicates,multibinder.permitsDuplicates());
  List<Binding<?>> elements = Lists.newArrayList(multibinder.getElements());
  List<BindResult> bindResults = Lists.newArrayList(results);
  assertEquals("wrong bind elements,expected: " + bindResults + ",but was: " + multibinder.getElements(),bindResults.size(),elements.size());

  for(BindResult result : bindResults) {
    Binding found = null;
    for(Binding item : elements) {
      switch (result.type) {
      case INSTANCE:
        if (item instanceof InstanceBinding
            && ((InstanceBinding) item).getInstance().equals(result.instance)) {
          found = item;
        }
        break;
      case LINKED:
        if (item instanceof LinkedKeyBinding
            && ((LinkedKeyBinding) item).getKey().equals(result.key)) {
          found = item;
        }
        break;
      case PROVIDER_INSTANCE:
        if (item instanceof ProviderInstanceBinding
            && ((ProviderInstanceBinding) item).getProviderInstance().get().equals(
                result.instance)) {
          found = item;
        }
        break;
      }
    }
    if(found == null) {
      fail("Could not find element: " + result + " in remaining elements: " + elements);
    } else {
      elements.remove(found);
    }
  }

  if(!elements.isEmpty()) {
    fail("Found all elements of: " + bindResults + ",but more were left over: " + elements);
  }

  Set<Binding> setofElements = new HashSet<Binding>(multibinder.getElements()); 

  List<Object> otherMultibinders = Lists.newArrayList();
  List<Binding> otherContains = Lists.newArrayList();
  for(Binding b : injector.getAllBindings().values()) {
    boolean contains = multibinder.containsElement(b);
    Object visited = b.acceptTargetVisitor(visitor);
    if(visited != null) {
      if(visited.equals(multibinder)) {
        assertTrue(contains);
      } else {
        otherMultibinders.add(visited);
      }
    } else if(setofElements.contains(b)) {
      assertTrue(contains);
    } else if(contains) {
      otherContains.add(b);
    }
  }

  if(allowDuplicates) {
    assertEquals("contained more than it should: " + otherContains,1,otherContains.size());
  } else {
    assertTrue("contained more than it should: " + otherContains,otherContains.isEmpty());
  }
  assertEquals("other multibindings found: " + otherMultibinders,otherMultibindings,otherMultibinders.size());

}

private static String instantiation(Binding<?> binding) {
  if (binding instanceof InstanceBinding<?>) {
    return instanceLiteral((InstanceBinding<?>) binding);
  } else if (binding instanceof ProviderKeyBinding<?>) {
    return providerCall(((ProviderKeyBinding<?>) binding).getProviderKey()) + ".get()";
  } else if (binding instanceof LinkedKeyBinding<?>) {
    return providerCall(((LinkedKeyBinding<?>) binding).getLinkedKey());
  } else if (binding instanceof ConstructorBinding<?>) {
    return constructorCall((ConstructorBinding<?>) binding);
  } else if (binding instanceof ProviderBinding<?>) {
    return provider((ProviderBinding<?>) binding);
  } else if (binding instanceof ProviderInstanceBinding<?>) {
    return instantiation((ProviderInstanceBinding<?>) binding);
  } else {
    throw new DeguicifierException();
  }
}

public Void visit(ProviderKeyBinding<? extends T> providerKeyBinding) {
  Context context = Context.forElement(providerKeyBinding);
  bindingsCollection.addBinding(
      targetKey,bindingFactory.getBindProviderBinding(
          providerKeyBinding.getProviderKey(),providerKeyBinding.getKey(),context));

  return null;
}

@Test
public void binds_provider_key() {
  given(module = new AbstractModule() {
    @Override
    protected void configure() {
      bind(Interface.class).toProvider(InterfaceProvider.class);
    }
  });
  given(injector = Guice.createInjector(module));
  when(injector.getBinding(Interface.class));
  thenReturned(instanceOf(ProviderKeyBinding.class));
}

/**
 * Same as {@link #visit(LinkedKeyBinding)},but the binding edge is {@link
 * BindingEdge.Type#PROVIDER}.
 */
@Override
public Collection<Edge> visit(ProviderKeyBinding<?> binding) {
  return ImmutableList.<Edge>of(
      new BindingEdge(
          NodeId.newTypeId(binding.getKey()),NodeId.newTypeId(binding.getProviderKey()),BindingEdge.Type.PROVIDER));
}

public void testVisitProviderKey() {
  Binding<?> binding = getBinding(Key.get(ConstructedClass.class),new ProviderKeyModule());
  Collection<Key<?>> dependencies = visitor.visit((ProviderKeyBinding<?>) binding);

  // Dependency should be to the class that provides this one.
  assertDependencies(dependencies,Key.get(ConstructedClassprovider.class));
}

@Override
public String toString() {
  return MoreObjects.toStringHelper(ProviderKeyBinding.class)
      .add("key",getKey())
      .add("source",getSource())
      .add("scope",getscoping())
      .add("provider",providerKey)
      .toString();
}

private static boolean matches(Binding<?> item,BindResult<?> result) {
  switch (result.type) {
    case INSTANCE:
      if (item instanceof InstanceBinding
          && ((InstanceBinding) item).getInstance().equals(result.instance)) {
        return true;
      }
      break;
    case LINKED:
      if (item instanceof LinkedKeyBinding
          && ((LinkedKeyBinding) item).getLinkedKey().equals(result.key)) {
        return true;
      }
      break;
    case PROVIDER_INSTANCE:
      if (item instanceof ProviderInstanceBinding
          && Objects.equal(
              ((ProviderInstanceBinding) item).getUserSuppliedProvider().get(),result.instance)) {
        return true;
      }
      break;
    case PROVIDER_KEY:
      if (item instanceof ProviderKeyBinding
          && ((ProviderKeyBinding) item).getProviderKey().equals(result.key)) {
        return true;
      }
      break;
  }
  return false;
}

public void testVisitProviderKey() {
  Binding<?> binding = getBinding(Key.get(ConstructedClass.class),Key.get(ConstructedClassprovider.class));
}

private static boolean matches(Binding<?> item,BindResult<?> result) {
  switch (result.type) {
  case INSTANCE:
    if (item instanceof InstanceBinding
        && ((InstanceBinding) item).getInstance().equals(result.instance)) {
      return true;
    }
    break;
  case LINKED:
    if (item instanceof LinkedKeyBinding
        && ((LinkedKeyBinding) item).getLinkedKey().equals(result.key)) {
      return true;
    }
    break;
  case PROVIDER_INSTANCE:
    if (item instanceof ProviderInstanceBinding
        && Objects.equal(((ProviderInstanceBinding) item).getUserSuppliedProvider().get(),result.instance)) {
      return true;
    }
    break;
  case PROVIDER_KEY:
    if (item instanceof ProviderKeyBinding
        && ((ProviderKeyBinding) item).getProviderKey().equals(result.key)) {
      return true;
    }
    break;
  }
  return false;
}

@Override public String toString() {
  return Objects.toStringHelper(ProviderKeyBinding.class)
      .add("key",providerKey)
      .toString();
}

public void testVisitProviderKey() {
  Binding<?> binding = getBinding(Key.get(ConstructedClass.class),Key.get(ConstructedClassprovider.class));
}

@Override public String toString() {
  return Objects.toStringHelper(ProviderKeyBinding.class)
      .add("key",providerKey)
      .toString();
}

@Override
public Optional<TypeLiteral<?>> visit(ProviderKeyBinding<?> binding) {
    // We don't kNow what the provider will return
    return empty();
}

@Override
public Object visit(ProviderKeyBinding<? extends T> providerKeyBinding) {
    requireKey(providerKeyBinding.getProviderKey());
    return super.visit(providerKeyBinding);
}

@Override
public Void visit(ProviderKeyBinding<? extends T> binding) {
    scope(binding,rebind(binding).toProvider(binding.getProviderKey()));
    return null;
}

@Override
public Collection<Key<?>> visit(ProviderKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getProviderKey());
}

@Override
public Indexer.IndexedBinding visit(ProviderKeyBinding<? extends Object> binding) {
  return new Indexer.IndexedBinding(
      binding,BindingType.PROVIDER_KEY,scope(binding),binding.getProviderKey());
}

@Override
public ResolvedBinding<T> visit(ProviderKeyBinding<? extends T> providerKeyBinding) {
  //noinspection unchecked
  return injector.getBinding(((Key<? extends T>)providerKeyBinding.getProviderKey())).acceptTargetVisitor(this);
}

@Override public Collection<Key<?>> visit(ProviderKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getProviderKey());
}

/**
 * Same as {@link #visit(LinkedKeyBinding)},but the binding edge is
 * {@link BindingEdge.Type#PROVIDER}.
 */
@Override public Collection<Edge> visit(ProviderKeyBinding<?> binding) {
  return ImmutableList.<Edge>of(new BindingEdge(NodeId.newTypeId(binding.getKey()),BindingEdge.Type.PROVIDER));
}

@Override public Collection<Key<?>> visit(ProviderKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getProviderKey());
}

/**
 * Same as {@link #visit(LinkedKeyBinding)},BindingEdge.Type.PROVIDER));
}