com.google.web.bindery.requestfactory.apt.ProxyScanner Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gwt-user Show documentation
There is a newer version: 2.10.0
/*
 * 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.web.bindery.requestfactory.apt;

import com.google.gwt.dev.util.Name.BinaryName;
import com.google.web.bindery.requestfactory.shared.JsonRpcProxy;
import com.google.web.bindery.requestfactory.shared.ProxyFor;
import com.google.web.bindery.requestfactory.shared.ProxyForName;

import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.MirroredTypeException;
import javax.lang.model.type.TypeMirror;

/**
 * Examines the methods declared in a proxy interface. Also records the client
 * to domain mapping for the proxy type.
 */
class ProxyScanner extends ScannerBase {

  private TypeElement checkedElement;

  @Override
  public Void visitExecutable(ExecutableElement x, State state) {
    if (shouldIgnore(x, state)) {
      return null;
    }

    ExecutableType xType = viewIn(checkedElement, x, state);
    if (isGetter(x, state)) {
      TypeMirror returnType = xType.getReturnType();
      if (!state.isTransportableType(returnType)) {
        // XXX(t.broyer): should we really pass the "resolved" type? that could
        // result in several errors being reported on the same method, but on
        // the other hand tells exactly which type it is that isn't
        // transportable.
        // For instance, a List might be transportable if T is
        // java.lang.String in a sub-interface, but not if T is some
        // untransportable type in another sub-interface
        state.poison(x, Messages.untransportableType(returnType));
      }
    } else if (!isSetter(x, state)) {
      state.poison(x, Messages.proxyOnlyGettersSetters());
    }

    // check parameters (we do not defer to visitVariable, as we need the
    // resolved generics)
    int i = 0;
    for (TypeMirror parameterType : xType.getParameterTypes()) {
      if (!state.isTransportableType(parameterType)) {
        // see comments above about the returnType
        state.poison(x.getParameters().get(i), Messages.untransportableType(parameterType));
      }
      i++;
    }
    return null;
  }

  @Override
  public Void visitType(TypeElement x, State state) {
    checkedElement = x;
    ProxyFor proxyFor = x.getAnnotation(ProxyFor.class);
    ProxyForName proxyForName = x.getAnnotation(ProxyForName.class);
    JsonRpcProxy jsonRpcProxy = x.getAnnotation(JsonRpcProxy.class);
    if (proxyFor != null) {
      poisonIfAnnotationPresent(state, x, proxyForName, jsonRpcProxy);

      // See javadoc on Element.getAnnotation() for why it works this way
      try {
        proxyFor.value();
        throw new RuntimeException("Should not reach here");
      } catch (MirroredTypeException expected) {
        TypeMirror type = expected.getTypeMirror();
        state.addMapping(x, (TypeElement) state.types.asElement(type));
      }
    }
    if (proxyForName != null) {
      poisonIfAnnotationPresent(state, x, jsonRpcProxy);
      TypeElement domain =
          state.elements.getTypeElement(BinaryName.toSourceName(proxyForName.value()));
      if (domain == null) {
        state.warn(x, Messages.proxyMissingDomainType(proxyForName.value()));
      }
      state.addMapping(x, domain);
    }

    scanAllInheritedMethods(x, state);
    state.checkExtraTypes(x);
    return null;
  }

  @Override
  public Void visitVariable(VariableElement x, State state) {
    if (!state.isTransportableType(x.asType())) {
      state.poison(x, Messages.untransportableType(x.asType()));
    }
    return super.visitVariable(x, state);
  }

  @Override
  protected boolean shouldIgnore(ExecutableElement x, State state) {
    // Ignore overrides of stableId()
    if (x.getSimpleName().contentEquals("stableId") && x.getParameters().isEmpty()) {
      return true;
    }
    return super.shouldIgnore(x, state);
  }
}