user/src/com/google/web/bindery/requestfactory/apt/State.java - gwt - Git at Google

 /*
  * 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.web.bindery.requestfactory.shared.SkipInterfaceValidation;

 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;

 import javax.annotation.processing.Filer;
 import javax.annotation.processing.Messager;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.type.TypeVariable;
 import javax.lang.model.util.Elements;
 import javax.lang.model.util.Types;
 import javax.tools.Diagnostic.Kind;

 class State {
   /**
    * Slightly tweaked implementation used when running tests.
    */
   static class ForTesting extends State {
     public ForTesting(ProcessingEnvironment processingEnv) {
       super(processingEnv);
     }

     @Override
     boolean respectAnnotations() {
       return false;
     }
   }

   /**
    * Implements comparable for priority ordering.
    */
   private static class Job implements Comparable<Job> {
     private static long count;

     public final TypeElement element;
     public final ScannerBase<?> scanner;
     private final long order = count++;
     private final int priority;

     public Job(TypeElement element, ScannerBase<?> scanner, int priority) {
       this.element = element;
       this.priority = priority;
       this.scanner = scanner;
     }

     @Override
     public int compareTo(Job o) {
       int c = priority - o.priority;
       if (c != 0) {
         return c;
       }
       return Long.signum(order - o.order);
     }

     @Override
     public String toString() {
       return scanner.getClass().getSimpleName() + " " + element.getSimpleName();
     }
   }

   /**
    * Used to take a {@code FooRequest extends Request<Foo>} and find the
    * {@code Request<Foo>} type.
    */
   static TypeMirror viewAs(DeclaredType desiredType, TypeMirror searchFrom, State state) {
     if (!desiredType.getTypeArguments().isEmpty()) {
       throw new IllegalArgumentException("Expecting raw type, received " + desiredType.toString());
     }
     Element searchElement = state.types.asElement(searchFrom);
     switch (searchElement.getKind()) {
       case CLASS:
       case INTERFACE:
       case ENUM: {
         TypeMirror rawSearchFrom = state.types.getDeclaredType((TypeElement) searchElement);
         if (state.types.isSameType(desiredType, rawSearchFrom)) {
           return searchFrom;
         }
         for (TypeMirror s : state.types.directSupertypes(searchFrom)) {
           TypeMirror maybe = viewAs(desiredType, s, state);
           if (maybe != null) {
             return maybe;
           }
         }
         break;
       }
       case TYPE_PARAMETER: {
         // Search <T extends Foo> as Foo
         return viewAs(desiredType, ((TypeVariable) searchElement).getUpperBound(), state);
       }
     }
     return null;
   }

   final TypeMirror baseProxyType;
   final Elements elements;
   final DeclaredType entityProxyIdType;
   final DeclaredType entityProxyType;
   final DeclaredType extraTypesAnnotation;
   final Filer filer;
   final DeclaredType instanceRequestType;
   final DeclaredType locatorType;
   final DeclaredType objectType;
   final DeclaredType requestContextType;
   final DeclaredType requestFactoryType;
   final DeclaredType requestType;
   final DeclaredType serviceLocatorType;
   final Set<TypeElement> seen;
   final Types types;
   final DeclaredType valueProxyType;
   private final Map<Element, Element> clientToDomainMain;
   private final SortedSet<Job> jobs = new TreeSet<Job>();
   private final Messager messager;
   private boolean poisoned;
   private boolean requireAllMappings;
   private final boolean suppressErrors;
   private final boolean suppressWarnings;
   private final boolean verbose;
   /**
    * Prevents duplicate messages from being emitted.
    */
   private final Map<Element, Set<String>> previousMessages = new HashMap<Element, Set<String>>();

   private final Set<TypeElement> typesRequiringMapping = new LinkedHashSet<TypeElement>();
   private boolean clientOnly;

   public State(ProcessingEnvironment processingEnv) {
     clientToDomainMain = new HashMap<Element, Element>();
     elements = processingEnv.getElementUtils();
     filer = processingEnv.getFiler();
     messager = processingEnv.getMessager();
     types = processingEnv.getTypeUtils();
     suppressErrors = Boolean.parseBoolean(processingEnv.getOptions().get("suppressErrors"));
     suppressWarnings = Boolean.parseBoolean(processingEnv.getOptions().get("suppressWarnings"));
     verbose = Boolean.parseBoolean(processingEnv.getOptions().get("verbose"));

     baseProxyType = findType("BaseProxy");
     entityProxyType = findType("EntityProxy");
     entityProxyIdType = findType("EntityProxyId");
     extraTypesAnnotation = findType("ExtraTypes");
     instanceRequestType = findType("InstanceRequest");
     locatorType = findType("Locator");
     objectType = findType(Object.class);
     requestType = findType("Request");
     requestContextType = findType("RequestContext");
     requestFactoryType = findType("RequestFactory");
     seen = new HashSet<TypeElement>();
     serviceLocatorType = findType("ServiceLocator");
     valueProxyType = findType("ValueProxy");
   }

   /**
    * Add a mapping from a client method to a domain method.
    */
   public void addMapping(ExecutableElement clientMethod, ExecutableElement domainMethod) {
     if (domainMethod == null) {
       debug(clientMethod, "No domain mapping");
     } else {
       debug(clientMethod, "Found domain method %s", domainMethod.toString());
     }
     clientToDomainMain.put(clientMethod, domainMethod);
   }

   /**
    * Add a mapping from a client type to a domain type.
    */
   public void addMapping(TypeElement clientType, TypeElement domainType) {
     if (domainType == null) {
       debug(clientType, "No domain mapping");
     } else {
       debug(clientType, "Found domain type %s", domainType.toString());
     }
     clientToDomainMain.put(clientType, domainType);
   }

   /**
    * Check an element for an {@code ExtraTypes} annotation. Handles both methods
    * and types.
    */
   public void checkExtraTypes(Element x) {
     (new ExtraTypesScanner<Void>() {
       @Override
       public Void visitExecutable(ExecutableElement x, State state) {
         checkForAnnotation(x, state);
         return null;
       }

       @Override
       public Void visitType(TypeElement x, State state) {
         checkForAnnotation(x, state);
         return null;
       }

       @Override
       protected void scanExtraType(TypeElement extraType) {
         maybeScanProxy(extraType);
       }
     }).scan(x, this);
   }

   /**
    * Print a warning message if verbose mode is enabled. A warning is used to
    * ensure that the message shows up in Eclipse's editor (a note only makes it
    * into the error console).
    */
   public void debug(Element elt, String message, Object... args) {
     if (verbose) {
       messager.printMessage(Kind.WARNING, String.format(message, args), elt);
     }
   }

   public void executeJobs() {
     while (!jobs.isEmpty()) {
       Job job = jobs.first();
       jobs.remove(job);
       debug(job.element, "Scanning");
       try {
         job.scanner.scan(job.element, this);
       } catch (HaltException ignored) {
         // Already reported
       } catch (Throwable e) {
         StringWriter sw = new StringWriter();
         e.printStackTrace(new PrintWriter(sw));
         poison(job.element, sw.toString());
       }
     }
     if (clientOnly) {
       // Don't want to check for mappings in client-only mode
       return;
     }
     for (TypeElement element : typesRequiringMapping) {
       if (!getClientToDomainMap().containsKey(element)) {
         if (types.isAssignable(element.asType(), requestContextType)) {
           poison(element, Messages.contextMustBeAnnotated(element.getSimpleName()));
         } else {
           poison(element, Messages.proxyMustBeAnnotated(element.getSimpleName()));
         }
       }
     }
   }

   /**
    * Utility method to look up raw types from class literals.
    */
   public DeclaredType findType(Class<?> clazz) {
     return types.getDeclaredType(elements.getTypeElement(clazz.getCanonicalName()));
   }

   /**
    * Returns a map of client elements to their domain counterparts. The keys may
    * be RequestContext or Proxy types or methods within those types.
    */
   public Map<Element, Element> getClientToDomainMap() {
     return Collections.unmodifiableMap(clientToDomainMain);
   }

   public boolean isClientOnly() {
     return clientOnly;
   }

   public boolean isMappingRequired(TypeElement element) {
     return typesRequiringMapping.contains(element);
   }

   public boolean isPoisoned() {
     return poisoned;
   }

   /**
    * Verifies that the given type may be used with RequestFactory.
    *
    * @see TransportableTypeVisitor
    */
   public boolean isTransportableType(TypeMirror asType) {
     return asType.accept(new TransportableTypeVisitor(), this);
   }

   public void maybeScanContext(TypeElement requestContext) {
     // Also ignore RequestContext itself
     if (fastFail(requestContext) || types.isSameType(requestContextType, requestContext.asType())) {
       return;
     }
     jobs.add(new Job(requestContext, new RequestContextScanner(), 0));
     if (!clientOnly) {
       jobs.add(new Job(requestContext, new DomainChecker(), 1));
     }
   }

   public void maybeScanFactory(TypeElement factoryType) {
     if (fastFail(factoryType) || types.isSameType(requestFactoryType, factoryType.asType())) {
       return;
     }
     jobs.add(new Job(factoryType, new RequestFactoryScanner(), 0));
     jobs.add(new Job(factoryType, new DeobfuscatorBuilder(), 2));
   }

   public void maybeScanProxy(TypeElement proxyType) {
     if (fastFail(proxyType)) {
       return;
     }
     jobs.add(new Job(proxyType, new ProxyScanner(), 0));
     if (!clientOnly) {
       jobs.add(new Job(proxyType, new DomainChecker(), 1));
     }
   }

   public boolean mustResolveAllAnnotations() {
     return requireAllMappings;
   }

   /**
    * Emits a fatal error message attached to an element. If the element or an
    * eclosing type is annotated with {@link SkipInterfaceValidation} the message
    * will be dropped.
    */
   public void poison(Element elt, String message) {
     if (suppressErrors) {
       return;
     }

     if (squelchMessage(elt, message)) {
       return;
     }

     if (respectAnnotations()) {
       Element check = elt;
       while (check != null) {
         if (check.getAnnotation(SkipInterfaceValidation.class) != null) {
           return;
         }
         check = check.getEnclosingElement();
       }
     }
     poisoned = true;
     if (elt == null) {
       messager.printMessage(Kind.ERROR, message);
     } else {
       messager.printMessage(Kind.ERROR, message, elt);
     }
   }

   public void requireMapping(TypeElement interfaceElement) {
     typesRequiringMapping.add(interfaceElement);
   }

   /**
    * Set to {@code true} to indicate that only JVM-client support code needs to
    * be generated.
    */
   public void setClientOnly(boolean clientOnly) {
     this.clientOnly = clientOnly;
   }

   /**
    * Set to {@code true} if it is an error for unresolved ProxyForName and
    * ServiceName annotations to be left over.
    */
   public void setMustResolveAllMappings(boolean requireAllMappings) {
     this.requireAllMappings = requireAllMappings;
   }

   /**
    * Emits a warning message, unless the element or an enclosing element are
    * annotated with a {@code @SuppressWarnings("requestfactory")}.
    */
   public void warn(Element elt, String message) {
     if (suppressWarnings) {
       return;
     }

     if (squelchMessage(elt, message)) {
       return;
     }

     if (respectAnnotations()) {
       SuppressWarnings suppress;
       Element check = elt;
       while (check != null) {
         if (check.getAnnotation(SkipInterfaceValidation.class) != null) {
           return;
         }
         suppress = check.getAnnotation(SuppressWarnings.class);
         if (suppress != null) {
           if (Arrays.asList(suppress.value()).contains("requestfactory")) {
             return;
           }
         }
         check = check.getEnclosingElement();
       }
     }

     messager.printMessage(Kind.WARNING, message + Messages.warnSuffix(), elt);
   }

   /**
    * This switch allows the RfValidatorTest code to be worked on in the IDE
    * without causing compilation failures.
    */
   boolean respectAnnotations() {
     return true;
   }

   private boolean fastFail(TypeElement element) {
     return !seen.add(element);
   }

   /**
    * Utility method to look up raw types from the requestfactory.shared package.
    * This method is used instead of class literals in order to minimize the
    * number of dependencies that get packed into {@code requestfactoy-apt.jar}.
    * If the requested type cannot be found, the State will be poisoned.
    */
   private DeclaredType findType(String simpleName) {
     TypeElement element =
         elements.getTypeElement("com.google.web.bindery.requestfactory.shared." + simpleName);
     if (element == null) {
       poison(null, "Unable to find RequestFactory built-in type. "
           + "Is requestfactory-[client|server].jar on the classpath?");
       return null;
     }
     return types.getDeclaredType(element);
   }

   /**
    * Prevents duplicate messages from being emitted.
    */
   private boolean squelchMessage(Element elt, String message) {
     Set<String> set = previousMessages.get(elt);
     if (set == null) {
       set = new HashSet<String>();
       // HashMap allows the null key
       previousMessages.put(elt, set);
     }
     return !set.add(message);
   }
 }
	/*
	* 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.web.bindery.requestfactory.shared.SkipInterfaceValidation;

	import java.io.PrintWriter;
	import java.io.StringWriter;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedHashSet;
	import java.util.Map;
	import java.util.Set;
	import java.util.SortedSet;
	import java.util.TreeSet;

	import javax.annotation.processing.Filer;
	import javax.annotation.processing.Messager;
	import javax.annotation.processing.ProcessingEnvironment;
	import javax.lang.model.element.Element;
	import javax.lang.model.element.ExecutableElement;
	import javax.lang.model.element.TypeElement;
	import javax.lang.model.type.DeclaredType;
	import javax.lang.model.type.TypeMirror;
	import javax.lang.model.type.TypeVariable;
	import javax.lang.model.util.Elements;
	import javax.lang.model.util.Types;
	import javax.tools.Diagnostic.Kind;

	class State {
	/**
	* Slightly tweaked implementation used when running tests.
	*/
	static class ForTesting extends State {
	public ForTesting(ProcessingEnvironment processingEnv) {
	super(processingEnv);
	}

	@Override
	boolean respectAnnotations() {
	return false;
	}
	}

	/**
	* Implements comparable for priority ordering.
	*/
	private static class Job implements Comparable<Job> {
	private static long count;

	public final TypeElement element;
	public final ScannerBase<?> scanner;
	private final long order = count++;
	private final int priority;

	public Job(TypeElement element, ScannerBase<?> scanner, int priority) {
	this.element = element;
	this.priority = priority;
	this.scanner = scanner;
	}

	@Override
	public int compareTo(Job o) {
	int c = priority - o.priority;
	if (c != 0) {
	return c;
	}
	return Long.signum(order - o.order);
	}

	@Override
	public String toString() {
	return scanner.getClass().getSimpleName() + " " + element.getSimpleName();
	}
	}

	/**
	* Used to take a {@code FooRequest extends Request<Foo>} and find the
	* {@code Request<Foo>} type.
	*/
	static TypeMirror viewAs(DeclaredType desiredType, TypeMirror searchFrom, State state) {
	if (!desiredType.getTypeArguments().isEmpty()) {
	throw new IllegalArgumentException("Expecting raw type, received " + desiredType.toString());
	}
	Element searchElement = state.types.asElement(searchFrom);
	switch (searchElement.getKind()) {
	case CLASS:
	case INTERFACE:
	case ENUM: {
	TypeMirror rawSearchFrom = state.types.getDeclaredType((TypeElement) searchElement);
	if (state.types.isSameType(desiredType, rawSearchFrom)) {
	return searchFrom;
	}
	for (TypeMirror s : state.types.directSupertypes(searchFrom)) {
	TypeMirror maybe = viewAs(desiredType, s, state);
	if (maybe != null) {
	return maybe;
	}
	}
	break;
	}
	case TYPE_PARAMETER: {
	// Search <T extends Foo> as Foo
	return viewAs(desiredType, ((TypeVariable) searchElement).getUpperBound(), state);
	}
	}
	return null;
	}

	final TypeMirror baseProxyType;
	final Elements elements;
	final DeclaredType entityProxyIdType;
	final DeclaredType entityProxyType;
	final DeclaredType extraTypesAnnotation;
	final Filer filer;
	final DeclaredType instanceRequestType;
	final DeclaredType locatorType;
	final DeclaredType objectType;
	final DeclaredType requestContextType;
	final DeclaredType requestFactoryType;
	final DeclaredType requestType;
	final DeclaredType serviceLocatorType;
	final Set<TypeElement> seen;
	final Types types;
	final DeclaredType valueProxyType;
	private final Map<Element, Element> clientToDomainMain;
	private final SortedSet<Job> jobs = new TreeSet<Job>();
	private final Messager messager;
	private boolean poisoned;
	private boolean requireAllMappings;
	private final boolean suppressErrors;
	private final boolean suppressWarnings;
	private final boolean verbose;
	/**
	* Prevents duplicate messages from being emitted.
	*/
	private final Map<Element, Set<String>> previousMessages = new HashMap<Element, Set<String>>();

	private final Set<TypeElement> typesRequiringMapping = new LinkedHashSet<TypeElement>();
	private boolean clientOnly;

	public State(ProcessingEnvironment processingEnv) {
	clientToDomainMain = new HashMap<Element, Element>();
	elements = processingEnv.getElementUtils();
	filer = processingEnv.getFiler();
	messager = processingEnv.getMessager();
	types = processingEnv.getTypeUtils();
	suppressErrors = Boolean.parseBoolean(processingEnv.getOptions().get("suppressErrors"));
	suppressWarnings = Boolean.parseBoolean(processingEnv.getOptions().get("suppressWarnings"));
	verbose = Boolean.parseBoolean(processingEnv.getOptions().get("verbose"));

	baseProxyType = findType("BaseProxy");
	entityProxyType = findType("EntityProxy");
	entityProxyIdType = findType("EntityProxyId");
	extraTypesAnnotation = findType("ExtraTypes");
	instanceRequestType = findType("InstanceRequest");
	locatorType = findType("Locator");
	objectType = findType(Object.class);
	requestType = findType("Request");
	requestContextType = findType("RequestContext");
	requestFactoryType = findType("RequestFactory");
	seen = new HashSet<TypeElement>();
	serviceLocatorType = findType("ServiceLocator");
	valueProxyType = findType("ValueProxy");
	}

	/**
	* Add a mapping from a client method to a domain method.
	*/
	public void addMapping(ExecutableElement clientMethod, ExecutableElement domainMethod) {
	if (domainMethod == null) {
	debug(clientMethod, "No domain mapping");
	} else {
	debug(clientMethod, "Found domain method %s", domainMethod.toString());
	}
	clientToDomainMain.put(clientMethod, domainMethod);
	}

	/**
	* Add a mapping from a client type to a domain type.
	*/
	public void addMapping(TypeElement clientType, TypeElement domainType) {
	if (domainType == null) {
	debug(clientType, "No domain mapping");
	} else {
	debug(clientType, "Found domain type %s", domainType.toString());
	}
	clientToDomainMain.put(clientType, domainType);
	}

	/**
	* Check an element for an {@code ExtraTypes} annotation. Handles both methods
	* and types.
	*/
	public void checkExtraTypes(Element x) {
	(new ExtraTypesScanner<Void>() {
	@Override
	public Void visitExecutable(ExecutableElement x, State state) {
	checkForAnnotation(x, state);
	return null;
	}

	@Override
	public Void visitType(TypeElement x, State state) {
	checkForAnnotation(x, state);
	return null;
	}

	@Override
	protected void scanExtraType(TypeElement extraType) {
	maybeScanProxy(extraType);
	}
	}).scan(x, this);
	}

	/**
	* Print a warning message if verbose mode is enabled. A warning is used to
	* ensure that the message shows up in Eclipse's editor (a note only makes it
	* into the error console).
	*/
	public void debug(Element elt, String message, Object... args) {
	if (verbose) {
	messager.printMessage(Kind.WARNING, String.format(message, args), elt);
	}
	}

	public void executeJobs() {
	while (!jobs.isEmpty()) {
	Job job = jobs.first();
	jobs.remove(job);
	debug(job.element, "Scanning");
	try {
	job.scanner.scan(job.element, this);
	} catch (HaltException ignored) {
	// Already reported
	} catch (Throwable e) {
	StringWriter sw = new StringWriter();
	e.printStackTrace(new PrintWriter(sw));
	poison(job.element, sw.toString());
	}
	}
	if (clientOnly) {
	// Don't want to check for mappings in client-only mode
	return;
	}
	for (TypeElement element : typesRequiringMapping) {
	if (!getClientToDomainMap().containsKey(element)) {
	if (types.isAssignable(element.asType(), requestContextType)) {
	poison(element, Messages.contextMustBeAnnotated(element.getSimpleName()));
	} else {
	poison(element, Messages.proxyMustBeAnnotated(element.getSimpleName()));
	}
	}
	}
	}

	/**
	* Utility method to look up raw types from class literals.
	*/
	public DeclaredType findType(Class<?> clazz) {
	return types.getDeclaredType(elements.getTypeElement(clazz.getCanonicalName()));
	}

	/**
	* Returns a map of client elements to their domain counterparts. The keys may
	* be RequestContext or Proxy types or methods within those types.
	*/
	public Map<Element, Element> getClientToDomainMap() {
	return Collections.unmodifiableMap(clientToDomainMain);
	}

	public boolean isClientOnly() {
	return clientOnly;
	}

	public boolean isMappingRequired(TypeElement element) {
	return typesRequiringMapping.contains(element);
	}

	public boolean isPoisoned() {
	return poisoned;
	}

	/**
	* Verifies that the given type may be used with RequestFactory.
	*
	* @see TransportableTypeVisitor
	*/
	public boolean isTransportableType(TypeMirror asType) {
	return asType.accept(new TransportableTypeVisitor(), this);
	}

	public void maybeScanContext(TypeElement requestContext) {
	// Also ignore RequestContext itself
	if (fastFail(requestContext) \|\| types.isSameType(requestContextType, requestContext.asType())) {
	return;
	}
	jobs.add(new Job(requestContext, new RequestContextScanner(), 0));
	if (!clientOnly) {
	jobs.add(new Job(requestContext, new DomainChecker(), 1));
	}
	}

	public void maybeScanFactory(TypeElement factoryType) {
	if (fastFail(factoryType) \|\| types.isSameType(requestFactoryType, factoryType.asType())) {
	return;
	}
	jobs.add(new Job(factoryType, new RequestFactoryScanner(), 0));
	jobs.add(new Job(factoryType, new DeobfuscatorBuilder(), 2));
	}

	public void maybeScanProxy(TypeElement proxyType) {
	if (fastFail(proxyType)) {
	return;
	}
	jobs.add(new Job(proxyType, new ProxyScanner(), 0));
	if (!clientOnly) {
	jobs.add(new Job(proxyType, new DomainChecker(), 1));
	}
	}

	public boolean mustResolveAllAnnotations() {
	return requireAllMappings;
	}

	/**
	* Emits a fatal error message attached to an element. If the element or an
	* eclosing type is annotated with {@link SkipInterfaceValidation} the message
	* will be dropped.
	*/
	public void poison(Element elt, String message) {
	if (suppressErrors) {
	return;
	}

	if (squelchMessage(elt, message)) {
	return;
	}

	if (respectAnnotations()) {
	Element check = elt;
	while (check != null) {
	if (check.getAnnotation(SkipInterfaceValidation.class) != null) {
	return;
	}
	check = check.getEnclosingElement();
	}
	}
	poisoned = true;
	if (elt == null) {
	messager.printMessage(Kind.ERROR, message);
	} else {
	messager.printMessage(Kind.ERROR, message, elt);
	}
	}

	public void requireMapping(TypeElement interfaceElement) {
	typesRequiringMapping.add(interfaceElement);
	}

	/**
	* Set to {@code true} to indicate that only JVM-client support code needs to
	* be generated.
	*/
	public void setClientOnly(boolean clientOnly) {
	this.clientOnly = clientOnly;
	}

	/**
	* Set to {@code true} if it is an error for unresolved ProxyForName and
	* ServiceName annotations to be left over.
	*/
	public void setMustResolveAllMappings(boolean requireAllMappings) {
	this.requireAllMappings = requireAllMappings;
	}

	/**
	* Emits a warning message, unless the element or an enclosing element are
	* annotated with a {@code @SuppressWarnings("requestfactory")}.
	*/
	public void warn(Element elt, String message) {
	if (suppressWarnings) {
	return;
	}

	if (squelchMessage(elt, message)) {
	return;
	}

	if (respectAnnotations()) {
	SuppressWarnings suppress;
	Element check = elt;
	while (check != null) {
	if (check.getAnnotation(SkipInterfaceValidation.class) != null) {
	return;
	}
	suppress = check.getAnnotation(SuppressWarnings.class);
	if (suppress != null) {
	if (Arrays.asList(suppress.value()).contains("requestfactory")) {
	return;
	}
	}
	check = check.getEnclosingElement();
	}
	}

	messager.printMessage(Kind.WARNING, message + Messages.warnSuffix(), elt);
	}

	/**
	* This switch allows the RfValidatorTest code to be worked on in the IDE
	* without causing compilation failures.
	*/
	boolean respectAnnotations() {
	return true;
	}

	private boolean fastFail(TypeElement element) {
	return !seen.add(element);
	}

	/**
	* Utility method to look up raw types from the requestfactory.shared package.
	* This method is used instead of class literals in order to minimize the
	* number of dependencies that get packed into {@code requestfactoy-apt.jar}.
	* If the requested type cannot be found, the State will be poisoned.
	*/
	private DeclaredType findType(String simpleName) {
	TypeElement element =
	elements.getTypeElement("com.google.web.bindery.requestfactory.shared." + simpleName);
	if (element == null) {
	poison(null, "Unable to find RequestFactory built-in type. "
	+ "Is requestfactory-[client\|server].jar on the classpath?");
	return null;
	}
	return types.getDeclaredType(element);
	}

	/**
	* Prevents duplicate messages from being emitted.
	*/
	private boolean squelchMessage(Element elt, String message) {
	Set<String> set = previousMessages.get(elt);
	if (set == null) {
	set = new HashSet<String>();
	// HashMap allows the null key
	previousMessages.put(elt, set);
	}
	return !set.add(message);
	}
	}