ImplicitBindingCreator.java

/*
 * Copyright 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.inject.rebind.resolution;

import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.inject.client.AsyncProvider;
import com.google.gwt.inject.rebind.binding.BindClassBinding;
import com.google.gwt.inject.rebind.binding.BindConstantBinding;
import com.google.gwt.inject.rebind.binding.BindProviderBinding;
import com.google.gwt.inject.rebind.binding.Binding;
import com.google.gwt.inject.rebind.binding.BindingFactory;
import com.google.gwt.inject.rebind.binding.Context;
import com.google.gwt.inject.rebind.binding.RemoteServiceProxyBinding;
import com.google.gwt.inject.rebind.reflect.MethodLiteral;
import com.google.gwt.inject.rebind.reflect.ReflectUtil;
import com.google.gwt.inject.rebind.util.GuiceUtil;
import com.google.gwt.inject.rebind.util.PrettyPrinter;
import com.google.inject.ImplementedBy;
import com.google.inject.Inject;
import com.google.inject.Key;
import com.google.inject.ProvidedBy;
import com.google.inject.TypeLiteral;
import com.google.inject.assistedinject.Assisted;

import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import javax.inject.Provider;

/**
 * Class responsible for creating implicit bindings.  This returns the binding entry
 * that should be used for the given type.  It does not concern itself with satisfying
 * the dependencies or with figuring out where the binding should appear.  For that,
 * see {@link BindingResolver}.
 */
public class ImplicitBindingCreator {

  /**
   * Exception thrown to indicate an error occurred during binding creation.
   */
  public static class BindingCreationException extends Exception {

    /**
     * Create a new BindingCreationException using the given format string and arguments.  Will
     * create an exception with a message constructed with {@code String.format(msgFmt, args)}.
     */
    public BindingCreationException(String msgFmt, Object... args) {
      super(PrettyPrinter.format(msgFmt, args));
    }
  }

  private final BindingFactory bindingFactory;
  private final GeneratorContext generatorContext;
  private final TreeLogger logger;

  @Inject
  public ImplicitBindingCreator(BindingFactory bindingFactory, GeneratorContext generatorContext,
      @Assisted TreeLogger logger) {
    this.bindingFactory = bindingFactory;
    this.generatorContext = generatorContext;
    this.logger = logger;
  }

  /**
   * Creates the implicit binding
   */
  public Binding create(Key<?> key) throws BindingCreationException {
    TypeLiteral<?> type = key.getTypeLiteral();

    // All steps per:
    // http://code.google.com/p/google-guice/wiki/BindingResolution

    // 1. Explicit binding - already finished at this point.

    // 2. Ask parent injector.
    // 3. Ask child injector.
    // These bindings are created in BindingResolver and are not necessary here.

    // 4. Provider injections.
    if (isProviderKey(key)) {
      return bindingFactory.getImplicitProviderBinding(key);
      // TODO(bstoler): Scope the provider binding like the thing being provided?
    }

    // 4b. AsyncProvider injections.
    if (isAsyncProviderKey(key)) {
      return bindingFactory.getAsyncProviderBinding(key);
    }

    // 5. Convert constants.
    // Already covered by resolving explicit bindings.
    if (BindConstantBinding.isConstantKey(key)) {
      throw new BindingCreationException(
          "Binding requested for constant key '%s' but no explicit binding was found", key);
    }

    // 6. If the dependency has a binding annotation, give up.
    if (key.getAnnotation() != null || key.getAnnotationType() != null) {
      throw new BindingCreationException("No implementation bound for '%s' and an implicit binding"
          + " cannot be created because the type is annotated.", key);
    }

    // 7. If the dependency is an array or enum, give up.
    // Covered by step 5 (enum) and 11 (array).

    // 8. Handle TypeLiteral injections.
    // TODO(schmitt): Implement TypeLiteral injections.

    // 9. Use resolution annotations (@ImplementedBy, @ProvidedBy)
    ImplementedBy implementedBy = type.getRawType().getAnnotation(ImplementedBy.class);
    if (implementedBy != null) {
      return createImplementedByBinding(key, implementedBy);
    }

    ProvidedBy providedBy = type.getRawType().getAnnotation(ProvidedBy.class);
    if (providedBy != null) {
      return createProvidedByBinding(key, providedBy);
    }

    // 10. If the dependency is abstract or a non-static inner class, give up.
    // Abstract classes are handled by GWT.create.
    // TODO(schmitt): Introduce check.

    // 11. Use a single @Inject or public no-arguments constructor.
    return createImplicitBindingForClass(type);
  }

  private Binding createImplicitBindingForClass(TypeLiteral<?> type)
      throws BindingCreationException {
    // Either call the @Inject constructor or use GWT.create
    MethodLiteral<?, Constructor<?>> injectConstructor = getInjectConstructor(type);

    if (injectConstructor != null) {
      return bindingFactory.getCallConstructorBinding(injectConstructor);
    }

    if (shouldGwtDotCreate(type)) {
      if (RemoteServiceProxyBinding.isRemoteServiceProxy(type)) {
        return bindingFactory.getRemoteServiceProxyBinding(type);
      } else {
        return bindingFactory.getCallGwtDotCreateBinding(type);
      }
    }

    throw new BindingCreationException("No @Inject or default constructor found for %s", type);
  }

  /**
   * Returns {@code true} if the given type should be created automatically with
   * {@code GWT.create()}.
   *
   * <p>{@code GWT.create()} is used to create concrete classes with accessible
   * zero-argument constructors, and interfaces or classes with GWT rebind
   * rules.
   */
  private boolean shouldGwtDotCreate(TypeLiteral<?> typeLiteral) throws BindingCreationException {
    Class<?> rawType = typeLiteral.getRawType();
    if (rawType.isInterface()) {
      // Check whether we can GWT.create() the interface.

      // Remote service proxies don't have rebind rules; we handle them
      // specially by creating the corresponding synchronous interface (which
      // does have a rebind rule).
      if (RemoteServiceProxyBinding.isRemoteServiceProxy(typeLiteral)) {
        // We could check whether the synchronous interface has a rebind rule;
        // however, the user is probably expecting us to GWT.create() a service
        // interface for them.  If there isn't a rebind rule, a GWT rebind error
        // probably makes more sense than a Gin error.
        return true;
      }

      return hasRebindRule(rawType);
    } else {
      return hasAccessibleZeroArgConstructor(rawType) || hasRebindRule(rawType);
    }
  }

  private boolean hasRebindRule(Class<?> rawType) throws BindingCreationException {
    String canonicalName = rawType.getCanonicalName();
    if (canonicalName == null) {
      throw new BindingCreationException("Cannot inject a type with no canonical name: " + rawType);
    } else {
      return generatorContext.checkRebindRuleAvailable(canonicalName);
    }
  }

  /**
   * Returns true iff the passed type has a constructor with zero arguments
   * (default constructors included) and that constructor is non-private,
   * excepting constructors for private classes where the constructor may be of
   * any visibility.
   *
   * @param typeLiteral type to be checked for matching constructor
   * @return true if a matching constructor is present on the passed type
   */
  private boolean hasAccessibleZeroArgConstructor(Class<?> rawType) {
    Constructor<?> constructor;
    try {
      constructor = rawType.getDeclaredConstructor();
    } catch (NoSuchMethodException e) {
      return rawType.getDeclaredConstructors().length == 0;
    }

    return !ReflectUtil.isPrivate(constructor) || ReflectUtil.isPrivate(rawType);
  }

  private BindClassBinding createImplementedByBinding(Key<?> key, ImplementedBy implementedBy)
      throws BindingCreationException {
    Class<?> rawType = key.getTypeLiteral().getRawType();
    Class<?> implementationType = implementedBy.value();

    if (implementationType == rawType) {
      throw new BindingCreationException(
          "@ImplementedBy points to the same class it annotates: %s", rawType);
    }

    if (!rawType.isAssignableFrom(implementationType)) {
      throw new BindingCreationException("%s doesn't extend %s (while resolving @ImplementedBy)",
          implementationType, rawType);
    }

    return bindingFactory.getBindClassBinding(Key.get(implementationType), key,
        Context.forText("@ImplementedBy annotation"));
  }

  private BindProviderBinding createProvidedByBinding(Key<?> key, ProvidedBy providedBy)
      throws BindingCreationException {
    Class<?> rawType = key.getTypeLiteral().getRawType();
    Class<? extends Provider<?>> providerType = providedBy.value();

    if (providerType == rawType) {
      throw new BindingCreationException(
          "@ProvidedBy points to the same class it annotates: %s", rawType);
    }

    return bindingFactory.getBindProviderBinding(Key.get(providerType), key,
        Context.forText("@ProvidedBy annotation"));
  }

  private boolean isProviderKey(Key<?> key) {
    Type keyType = key.getTypeLiteral().getType();
    return keyType instanceof ParameterizedType &&
    (((ParameterizedType) keyType).getRawType() == Provider.class
        || ((ParameterizedType) keyType).getRawType() == com.google.inject.Provider.class);
  }

  private boolean isAsyncProviderKey(Key<?> key) {
    Type keyType = key.getTypeLiteral().getType();
    return keyType instanceof ParameterizedType &&
    ((ParameterizedType) keyType).getRawType() == AsyncProvider.class;
  }

  private MethodLiteral<?, Constructor<?>> getInjectConstructor(TypeLiteral<?> type)
      throws BindingCreationException {
    Constructor<?>[] constructors = type.getRawType().getDeclaredConstructors();
    MethodLiteral<?, Constructor<?>> injectConstructor = null;
    for (Constructor<?> constructor : constructors) {
      MethodLiteral<?, Constructor<?>> constructorLiteral = MethodLiteral.get(constructor, type);
      if (GuiceUtil.hasInject(constructorLiteral)) {
        if (injectConstructor != null) {
          throw new BindingCreationException(
              "More than one @Inject constructor found for %s; %s, %s",
              type, injectConstructor, constructorLiteral);
        }
        injectConstructor = constructorLiteral;
      }
    }
    return injectConstructor;
  }

  public interface Factory {
    ImplicitBindingCreator create(TreeLogger logger);
  }
}