first commit
First draft of a new, fast dependency JSR-330 injector.

This injector is roughly based on MiniGuice:
http://code.google.com/p/google-guice/source/browse/extensions/mini/src/com/google/inject/mini/MiniGuice.java

Unlike Guice, this injector uses only static configuration.
This will enable more up front checking as well as backends
that use code generation instead of reflection.

Current limitations:
 - no support for circular dependencies.
 - no method injection.
Address pom.xml problems
Address code review comments from bob@ and edenman@
Rename Linker.getBinding() to Linker.requestBinding().
More code review comments addressed.
Merge pull request #1 from square/firstdraft

First draft of a fast new JSR-330 dependency injector.
New, very basic Java code generator.

The code generator is only concerned with the high level
constructs; it relies on the caller to worry about making
sure the actual statements are well formed.
Fix tpyo in 'trailing'.
Merge pull request #2 from square/codegen

New, very basic Java code generator.
Add Modules.override().

This API is necessary to bootstrap the Square apps, which use
it for testing.
Suppress Modules' default constructor.
Fix some checkstyle issues.
Merge pull request #3 from square/jwilson/modulesoverride

Add Modules.override().
Use Strings for Keys.

Strings will be a little less type safe, but they're going
to be a lot easier to use with code generation. Otherwise
we'd need to implement all of the various 'Type' interfaces
and do hacks to guarantee equals and hashCode compatibility
with the built-in implementations.
Merge pull request #4 from square/jwilson/apt

Use Strings for Keys.
First draft of the @Provides processor.

Given input like this:

    package com.squareup;

    import com.squareup.injector.Provides;
    import javax.inject.Named;

    public class Hello {
      @Provides @Named("foo") String provideString(@Named("bar") Integer i) {
        return "foo";
      }
    }

This will generate a class like this:

    package com.squareup;
    import com.squareup.injector.internal.Binding;
    import com.squareup.injector.internal.ModuleAdapter;
    import java.util.Map;
    import com.squareup.injector.internal.Linker;
    public final class Hello$ModuleAdapter
        implements ModuleAdapter<Hello> {
      @Override
      public Map<String, Binding<?>> getBindings(Hello module) {
        java.util.Map<java.lang.String, com.squareup.injector.internal.Binding<?>> result = new java.util.HashMap<java.lang.String, com.squareup.injector.internal.Binding<?>>();
        result.put("@javax.inject.Named(value=foo)/java.lang.String", new provideStringBinding(module));
        return result;
      }
      private static class provideStringBinding
          extends Binding<String> {
        private final Hello module;
        private Binding<Integer> p0;
        public provideStringBinding(Hello module) {
          super(com.squareup.Hello.class, "@javax.inject.Named(value=foo)/java.lang.String");
          this.module = module;
        }
        @Override
        public void attach(Linker linker) {
          p0 = (com.squareup.injector.internal.Binding<java.lang.Integer>) linker.requestBinding("@javax.inject.Named(value=bar)/java.lang.Integer", com.squareup.Hello.class);
        }
        @Override
        public String get() {
          return module.provideString(p0.get());
        }
        @Override
        public boolean isSingleton() {
          return true;
        }
      }
    }
Fix some string format foolishness.
Fix GeneratorKeys visibility.
Merge pull request #5 from square/jwilson/providesprocessor

First draft of the @Provides processor.