user/src/com/google/gwt/i18n/rebind/AbstractLocalizableImplCreator.java - gwt - Git at Google

 /*
  * Copyright 2008 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.i18n.rebind;

 import static com.google.gwt.i18n.rebind.AnnotationUtil.getClassAnnotation;

 import com.google.gwt.core.ext.BadPropertyValueException;
 import com.google.gwt.core.ext.GeneratorContext;
 import com.google.gwt.core.ext.SelectionProperty;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.core.ext.linker.EmittedArtifact.Visibility;
 import com.google.gwt.core.ext.typeinfo.JClassType;
 import com.google.gwt.core.ext.typeinfo.JMethod;
 import com.google.gwt.core.ext.typeinfo.NotFoundException;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
 import com.google.gwt.i18n.client.LocalizableResource.Generate;
 import com.google.gwt.i18n.client.LocalizableResource.Key;
 import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
 import com.google.gwt.i18n.rebind.AnnotationsResource.AnnotationsError;
 import com.google.gwt.i18n.rebind.format.MessageCatalogFormat;
 import com.google.gwt.i18n.server.KeyGenerator;
 import com.google.gwt.i18n.server.MessageCatalogFactory;
 import com.google.gwt.i18n.server.MessageCatalogFactory.Context;
 import com.google.gwt.i18n.server.MessageCatalogFactory.Writer;
 import com.google.gwt.i18n.server.MessageInterface;
 import com.google.gwt.i18n.server.MessageProcessingException;
 import com.google.gwt.i18n.shared.GwtLocale;
 import com.google.gwt.i18n.shared.GwtLocaleFactory;
 import com.google.gwt.user.rebind.AbstractGeneratorClassCreator;
 import com.google.gwt.user.rebind.AbstractMethodCreator;
 import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
 import com.google.gwt.user.rebind.SourceWriter;

 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.UnsupportedEncodingException;
 import java.util.MissingResourceException;

 /**
  * Represents generic functionality needed for <code>Constants</code> and
  * <code>Messages</code> classes.
  */
 abstract class AbstractLocalizableImplCreator extends
     AbstractGeneratorClassCreator {

   public static class MessageCatalogContextImpl
       implements Context {

     private final GeneratorContext context;
     private final TreeLogger logger;

     public MessageCatalogContextImpl(GeneratorContext context,
         TreeLogger logger) {
       this.context = context;
       this.logger = logger;
     }

     public OutputStream createBinaryFile(String catalogName) {
       try {
         final OutputStream ostr = context.tryCreateResource(logger, catalogName);
         if (ostr != null) {
           // wrap the stream so we can commit the resource on close
           return new OutputStream() {

             @Override
             public void close() throws IOException {
               try {
                 context.commitResource(logger, ostr).setVisibility(
                     Visibility.Private);
               } catch (UnableToCompleteException e) {
                 // error already logged, anything more to do?
               }
             }

             @Override
             public void write(byte[] b, int off, int len) throws IOException {
               ostr.write(b, off, len);
             }

             @Override
             public void write(int b) throws IOException {
               ostr.write(b);
             }
           };
         }
       } catch (UnableToCompleteException e) {
         // error already logged, anything more to do?
       }
       return null;
     }

     public PrintWriter createTextFile(String catalogName, String charSet) {
       OutputStream outStr = createBinaryFile(catalogName);
       if (outStr != null) {
         try {
           return new PrintWriter(new BufferedWriter(
               new OutputStreamWriter(outStr, "UTF-8")), false);
         } catch (UnsupportedEncodingException e) {
           error("UTF-8 not supported", e);
         }
       }
       return null;
     }

     public void error(String msg) {
       logger.log(TreeLogger.ERROR, msg);
     }

     public void error(String msg, Throwable cause) {
       logger.log(TreeLogger.ERROR, msg, cause);
     }

     public GwtLocaleFactory getLocaleFactory() {
       return LocaleUtils.getLocaleFactory();
     }

     public void warning(String msg) {
       logger.log(TreeLogger.WARN, msg);
     }

     public void warning(String msg, Throwable cause) {
       logger.log(TreeLogger.WARN, msg, cause);
     }
   }

   static String generateConstantOrMessageClass(TreeLogger logger,
       GeneratorContext context, GwtLocale locale, JClassType targetClass)
       throws UnableToCompleteException {
     TypeOracle oracle = context.getTypeOracle();
     JClassType constantsClass;
     JClassType messagesClass;
     JClassType constantsWithLookupClass;
     boolean seenError = false;
     try {
       constantsClass = oracle.getType(LocalizableGenerator.CONSTANTS_NAME);
       constantsWithLookupClass = oracle.getType(LocalizableGenerator.CONSTANTS_WITH_LOOKUP_NAME);
       messagesClass = oracle.getType(LocalizableGenerator.MESSAGES_NAME);
     } catch (NotFoundException e) {
       // Should never happen in practice.
       throw error(logger, e);
     }

     String name = targetClass.getName();
     String packageName = targetClass.getPackage().getName();

     // Make sure the interface being rebound extends either Constants or
     // Messages.
     boolean assignableToConstants = constantsClass.isAssignableFrom(targetClass);
     boolean assignableToMessages = messagesClass.isAssignableFrom(targetClass);
     if (!assignableToConstants && !assignableToMessages) {
       // Let the implementation generator handle this interface.
       return null;
     }

     // Make sure that they don't try to extend both Messages and Constants.
     if (assignableToConstants && assignableToMessages) {
       throw error(logger, name + " cannot extend both Constants and Messages");
     }

     // Make sure that the type being rebound is in fact an interface.
     if (targetClass.isInterface() == null) {
       throw error(logger, name + " must be an interface");
     }

     ResourceList resourceList = null;
     try {
       resourceList = ResourceFactory.getBundle(logger, targetClass, locale,
           assignableToConstants, context.getResourcesOracle().getResourceMap(), context);
     } catch (MissingResourceException e) {
       throw error(logger,
           "Localization failed; there must be at least one resource accessible through"
               + " the classpath in package '" + packageName
               + "' whose base name is '"
               + ResourceFactory.getResourceName(targetClass) + "'");
     } catch (IllegalArgumentException e) {
       // A bad key can generate an illegal argument exception.
       throw error(logger, e.getMessage());
     }

     // generated implementations for interface X will be named X_, X_en,
     // X_en_CA, etc.
     GwtLocale generatedLocale = resourceList.findLeastDerivedLocale(logger,
         locale);
     String localeSuffix = String.valueOf(ResourceFactory.LOCALE_SEPARATOR);
     localeSuffix += generatedLocale.getAsString();
     // Use _ rather than "." in class name, cannot use $
     String resourceName = targetClass.getName().replace('.', '_');
     String className = resourceName + localeSuffix;
     PrintWriter pw = context.tryCreate(logger, packageName, className);
     if (pw != null) {
       ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(
           packageName, className);
       factory.addImplementedInterface(targetClass.getQualifiedSourceName());
       SourceWriter writer = factory.createSourceWriter(context, pw);
       // Now that we have all the information set up, process the class
       if (constantsWithLookupClass.isAssignableFrom(targetClass)) {
         ConstantsWithLookupImplCreator c = new ConstantsWithLookupImplCreator(
             logger, writer, targetClass, resourceList, context.getTypeOracle());
         c.emitClass(logger, generatedLocale);
       } else if (constantsClass.isAssignableFrom(targetClass)) {
         ConstantsImplCreator c = new ConstantsImplCreator(logger, writer,
             targetClass, resourceList, context.getTypeOracle());
         c.emitClass(logger, generatedLocale);
       } else {
         MessagesImplCreator messages = new MessagesImplCreator(logger, writer,
             targetClass, resourceList, context.getTypeOracle());
         messages.emitClass(logger, generatedLocale);
       }
       context.commit(logger, pw);
     }
     // Generate a translatable output file if requested.
     Generate generate = getClassAnnotation(targetClass, Generate.class);
     if (generate != null) {
       String path = generate.fileName();
       if (Generate.DEFAULT.equals(path)) {
         path = targetClass.getPackage().getName() + "."
             + targetClass.getName().replace('.', '_');
       } else if (path.endsWith(File.pathSeparator)) {
         path = path + targetClass.getName().replace('.', '_');
       }
       String[] genLocales = generate.locales();
       boolean found = false;
       if (genLocales.length != 0) {
         // verify the current locale is in the list
         for (String genLocale : genLocales) {
           if (GwtLocale.DEFAULT_LOCALE.equals(genLocale)) {
             // Locale "default" gets special handling because of property
             // fallbacks; "default" might be mapped to any real locale.
             try {
               SelectionProperty localeProp = context.getPropertyOracle()
                   .getSelectionProperty(logger, "locale");
               String defaultLocale = localeProp.getFallbackValue();
               if (defaultLocale.length() > 0) {
                 genLocale = defaultLocale;
               }
             } catch (BadPropertyValueException e) {
               throw error(logger, "Could not get 'locale' property");
             }
           }
           if (genLocale.equals(locale.toString())) {
             found = true;
             break;
           }
         }
       } else {
         // Since they want all locales, this is guaranteed to be one of them.
         found = true;
       }
       if (found) {
         for (String genClassName : generate.format()) {
           MessageCatalogFormat msgWriter = null;
           MessageCatalogFactory msgCatFactory = null;
           try {
             // TODO(jat): if GWT is ever modified to take a classpath for user
             // code as an option, we would need to use the user classloader here
             Class<?> clazz = Class.forName(genClassName, false,
                 MessageCatalogFormat.class.getClassLoader());
             if (MessageCatalogFormat.class.isAssignableFrom(clazz)) {
               Class<? extends MessageCatalogFormat> msgFormatClass
                   = clazz.asSubclass(MessageCatalogFormat.class);
               msgWriter = msgFormatClass.newInstance();
             } else if (MessageCatalogFactory.class.isAssignableFrom(clazz)) {
               Class<? extends MessageCatalogFactory> msgFactoryClass
                   = clazz.asSubclass(MessageCatalogFactory.class);
               msgCatFactory = msgFactoryClass.newInstance();
             } else {
               logger.log(TreeLogger.ERROR, "Class specified in @Generate must "
                   + "either be a subtype of MessageCatalogFormat or "
                   + "MessageCatalogFactory");
               seenError = true;
               continue;
             }
           } catch (InstantiationException e) {
             logger.log(TreeLogger.ERROR, "Error instantiating @Generate class "
                 + genClassName, e);
             seenError = true;
             continue;
           } catch (IllegalAccessException e) {
             logger.log(TreeLogger.ERROR, "@Generate class " + genClassName
                 + " illegal access", e);
             seenError = true;
             continue;
           } catch (ClassNotFoundException e) {
             logger.log(TreeLogger.ERROR, "@Generate class " + genClassName
                 + " not found");
             seenError = true;
             continue;
           }
           // Make generator-specific changes to a temporary copy of the path.
           String genPath = path;
           if (genLocales.length != 1) {
             // If the user explicitly specified only one locale, do not add the
             // locale.
             genPath += '_' + locale.toString();
           }
           if (msgCatFactory != null) {
             seenError |= generateToMsgCatFactory(logger, context, locale,
                 targetClass, seenError, resourceList, msgCatFactory, genPath);
           } else if (msgWriter != null) {
             seenError |= generateToLegacyMsgCatFormat(logger, context, locale,
                 targetClass, seenError, resourceList, className, msgWriter,
                 genPath);
           }
         }
       }
     }
     if (seenError) {
       // If one of our generators had a fatal error, don't complete normally.
       throw new UnableToCompleteException();
     }
     return packageName + "." + className;
   }

   /**
    * Write translation source files to the old-style
    * {@link MessageCatalogFormat}.
    *
    * @param logger
    * @param context
    * @param locale
    * @param targetClass
    * @param seenError
    * @param resourceList
    * @param className
    * @param msgWriter
    * @param genPath
    * @return true if an error occurred (already logged)
    * @throws UnableToCompleteException
    */

   private static boolean generateToLegacyMsgCatFormat(TreeLogger logger,
       GeneratorContext context, GwtLocale locale, JClassType targetClass,
       boolean seenError, ResourceList resourceList, String className,
       MessageCatalogFormat msgWriter, String genPath)
       throws UnableToCompleteException {
     genPath += msgWriter.getExtension();
     OutputStream outStr = context.tryCreateResource(logger, genPath);
     if (outStr != null) {
       TreeLogger branch = logger.branch(TreeLogger.TRACE, "Generating "
           + genPath + " from " + className + " for locale " + locale,
           null);
       PrintWriter out = null;
       try {
         out = new PrintWriter(new BufferedWriter(
             new OutputStreamWriter(outStr, "UTF-8")), false);
       } catch (UnsupportedEncodingException e) {
         throw error(logger, "UTF-8 not supported", e);
       }
       try {
         msgWriter.write(branch, locale.toString(), resourceList, out,
             targetClass);
         out.flush();
         context.commitResource(logger, outStr).setVisibility(
             Visibility.Private);
       } catch (UnableToCompleteException e) {
         // msgWriter should have already logged an error message.
         // Keep going for now so we can find other errors.
         seenError = true;
       }
     }
     return seenError;
   }

   /**
    * Write translation source files to a {@link MessageCatalogFactory}.
    *
    * @param logger
    * @param context
    * @param locale
    * @param targetClass
    * @param seenError
    * @param resourceList
    * @param msgCatFactory
    * @param genPath
    * @return true if an error occurred (already logged)
    */
   private static boolean generateToMsgCatFactory(TreeLogger logger,
       GeneratorContext context, GwtLocale locale, JClassType targetClass, boolean seenError,
       ResourceList resourceList, MessageCatalogFactory msgCatFactory,
       String genPath) {
     // TODO(jat): maintain MessageCatalogWriter instances across
     // generator runs so they can save state.  One problem is knowing
     // when the last generator has been run.
     Writer catWriter = null;
     try {
       String catalogName = genPath + msgCatFactory.getExtension();
       Context ctx = new MessageCatalogContextImpl(
           context, logger);
       MessageInterface msgIntf = new TypeOracleMessageInterface(
           LocaleUtils.getLocaleFactory(), targetClass, resourceList);
       catWriter = msgCatFactory.getWriter(ctx, catalogName);
       if (catWriter == null) {
         if (logger.isLoggable(TreeLogger.TRACE)) {
           logger.log(TreeLogger.TRACE, "Already generated " + catalogName);
         }
         return false;
       }
       msgIntf.accept(catWriter.visitClass());
     } catch (MessageProcessingException e) {
       logger.log(TreeLogger.ERROR, e.getMessage(), e);
       seenError = true;
     } finally {
       if (catWriter != null) {
         try {
           catWriter.close();
         } catch (IOException e) {
           logger.log(TreeLogger.ERROR,
               "IO error closing catalog writer", e);
           seenError = true;
         }
       }
     }
     return seenError;
   }

   /**
    * Generator to use to create keys for messages.
    */
   private KeyGenerator keyGenerator;

   /**
    * The Dictionary/value bindings used to determine message contents.
    */
   private ResourceList resourceList;

   /**
    * True if the class being generated uses Constants-style annotations/quoting.
    */
   private boolean isConstants;

   /**
    * Constructor for <code>AbstractLocalizableImplCreator</code>.
    *
    * @param writer writer
    * @param targetClass current target
    * @param resourceList backing resource
    */
   public AbstractLocalizableImplCreator(TreeLogger logger, SourceWriter writer,
       JClassType targetClass, ResourceList resourceList, boolean isConstants) {
     super(writer, targetClass);
     this.resourceList = resourceList;
     this.isConstants = isConstants;
     try {
       keyGenerator = AnnotationsResource.getKeyGenerator(targetClass);
     } catch (AnnotationsError e) {
       logger.log(TreeLogger.WARN, "Error getting key generator for "
           + targetClass.getQualifiedSourceName(), e);
     }
   }

   /**
    * Gets the resource associated with this class.
    *
    * @return the resource
    */
   public ResourceList getResourceBundle() {
     return resourceList;
   }

   @Override
   protected String branchMessage() {
     return "Processing " + this.getTarget();
   }

   /**
    * Find the creator associated with the given method, and delegate the
    * creation of the method body to it.
    *
    * @param logger TreeLogger instance for logging
    * @param method method to be generated
    * @param locale locale to generate
    * @throws UnableToCompleteException
    */
   protected void delegateToCreator(TreeLogger logger, JMethod method,
       GwtLocale locale) throws UnableToCompleteException {
     AbstractMethodCreator methodCreator = getMethodCreator(logger, method);
     String key = getKey(logger, method);
     if (key == null) {
       logger.log(TreeLogger.ERROR, "Unable to get or compute key for method "
           + method.getName(), null);
       throw new UnableToCompleteException();
     }
     methodCreator.createMethodFor(logger, method, key, resourceList, locale);
   }

   /**
    * Returns a resource key given a method name.
    *
    * @param logger TreeLogger instance for logging
    * @param method method to get key for
    * @return the key to use for resource lookups or null if unable to get or
    *         compute the key
    */
   protected String getKey(TreeLogger logger, JMethod method) {
     Key key = method.getAnnotation(Key.class);
     if (key != null) {
       return key.value();
     }
     return AnnotationsResource.getKey(logger, keyGenerator, method, isConstants);
   }
 }
	/*
	* Copyright 2008 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.i18n.rebind;

	import static com.google.gwt.i18n.rebind.AnnotationUtil.getClassAnnotation;

	import com.google.gwt.core.ext.BadPropertyValueException;
	import com.google.gwt.core.ext.GeneratorContext;
	import com.google.gwt.core.ext.SelectionProperty;
	import com.google.gwt.core.ext.TreeLogger;
	import com.google.gwt.core.ext.UnableToCompleteException;
	import com.google.gwt.core.ext.linker.EmittedArtifact.Visibility;
	import com.google.gwt.core.ext.typeinfo.JClassType;
	import com.google.gwt.core.ext.typeinfo.JMethod;
	import com.google.gwt.core.ext.typeinfo.NotFoundException;
	import com.google.gwt.core.ext.typeinfo.TypeOracle;
	import com.google.gwt.i18n.client.LocalizableResource.Generate;
	import com.google.gwt.i18n.client.LocalizableResource.Key;
	import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
	import com.google.gwt.i18n.rebind.AnnotationsResource.AnnotationsError;
	import com.google.gwt.i18n.rebind.format.MessageCatalogFormat;
	import com.google.gwt.i18n.server.KeyGenerator;
	import com.google.gwt.i18n.server.MessageCatalogFactory;
	import com.google.gwt.i18n.server.MessageCatalogFactory.Context;
	import com.google.gwt.i18n.server.MessageCatalogFactory.Writer;
	import com.google.gwt.i18n.server.MessageInterface;
	import com.google.gwt.i18n.server.MessageProcessingException;
	import com.google.gwt.i18n.shared.GwtLocale;
	import com.google.gwt.i18n.shared.GwtLocaleFactory;
	import com.google.gwt.user.rebind.AbstractGeneratorClassCreator;
	import com.google.gwt.user.rebind.AbstractMethodCreator;
	import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
	import com.google.gwt.user.rebind.SourceWriter;

	import java.io.BufferedWriter;
	import java.io.File;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.OutputStreamWriter;
	import java.io.PrintWriter;
	import java.io.UnsupportedEncodingException;
	import java.util.MissingResourceException;

	/**
	* Represents generic functionality needed for <code>Constants</code> and
	* <code>Messages</code> classes.
	*/
	abstract class AbstractLocalizableImplCreator extends
	AbstractGeneratorClassCreator {

	public static class MessageCatalogContextImpl
	implements Context {

	private final GeneratorContext context;
	private final TreeLogger logger;

	public MessageCatalogContextImpl(GeneratorContext context,
	TreeLogger logger) {
	this.context = context;
	this.logger = logger;
	}

	public OutputStream createBinaryFile(String catalogName) {
	try {
	final OutputStream ostr = context.tryCreateResource(logger, catalogName);
	if (ostr != null) {
	// wrap the stream so we can commit the resource on close
	return new OutputStream() {

	@Override
	public void close() throws IOException {
	try {
	context.commitResource(logger, ostr).setVisibility(
	Visibility.Private);
	} catch (UnableToCompleteException e) {
	// error already logged, anything more to do?
	}
	}

	@Override
	public void write(byte[] b, int off, int len) throws IOException {
	ostr.write(b, off, len);
	}

	@Override
	public void write(int b) throws IOException {
	ostr.write(b);
	}
	};
	}
	} catch (UnableToCompleteException e) {
	// error already logged, anything more to do?
	}
	return null;
	}

	public PrintWriter createTextFile(String catalogName, String charSet) {
	OutputStream outStr = createBinaryFile(catalogName);
	if (outStr != null) {
	try {
	return new PrintWriter(new BufferedWriter(
	new OutputStreamWriter(outStr, "UTF-8")), false);
	} catch (UnsupportedEncodingException e) {
	error("UTF-8 not supported", e);
	}
	}
	return null;
	}

	public void error(String msg) {
	logger.log(TreeLogger.ERROR, msg);
	}

	public void error(String msg, Throwable cause) {
	logger.log(TreeLogger.ERROR, msg, cause);
	}

	public GwtLocaleFactory getLocaleFactory() {
	return LocaleUtils.getLocaleFactory();
	}

	public void warning(String msg) {
	logger.log(TreeLogger.WARN, msg);
	}

	public void warning(String msg, Throwable cause) {
	logger.log(TreeLogger.WARN, msg, cause);
	}
	}

	static String generateConstantOrMessageClass(TreeLogger logger,
	GeneratorContext context, GwtLocale locale, JClassType targetClass)
	throws UnableToCompleteException {
	TypeOracle oracle = context.getTypeOracle();
	JClassType constantsClass;
	JClassType messagesClass;
	JClassType constantsWithLookupClass;
	boolean seenError = false;
	try {
	constantsClass = oracle.getType(LocalizableGenerator.CONSTANTS_NAME);
	constantsWithLookupClass = oracle.getType(LocalizableGenerator.CONSTANTS_WITH_LOOKUP_NAME);
	messagesClass = oracle.getType(LocalizableGenerator.MESSAGES_NAME);
	} catch (NotFoundException e) {
	// Should never happen in practice.
	throw error(logger, e);
	}

	String name = targetClass.getName();
	String packageName = targetClass.getPackage().getName();

	// Make sure the interface being rebound extends either Constants or
	// Messages.
	boolean assignableToConstants = constantsClass.isAssignableFrom(targetClass);
	boolean assignableToMessages = messagesClass.isAssignableFrom(targetClass);
	if (!assignableToConstants && !assignableToMessages) {
	// Let the implementation generator handle this interface.
	return null;
	}

	// Make sure that they don't try to extend both Messages and Constants.
	if (assignableToConstants && assignableToMessages) {
	throw error(logger, name + " cannot extend both Constants and Messages");
	}

	// Make sure that the type being rebound is in fact an interface.
	if (targetClass.isInterface() == null) {
	throw error(logger, name + " must be an interface");
	}

	ResourceList resourceList = null;
	try {
	resourceList = ResourceFactory.getBundle(logger, targetClass, locale,
	assignableToConstants, context.getResourcesOracle().getResourceMap(), context);
	} catch (MissingResourceException e) {
	throw error(logger,
	"Localization failed; there must be at least one resource accessible through"
	+ " the classpath in package '" + packageName
	+ "' whose base name is '"
	+ ResourceFactory.getResourceName(targetClass) + "'");
	} catch (IllegalArgumentException e) {
	// A bad key can generate an illegal argument exception.
	throw error(logger, e.getMessage());
	}

	// generated implementations for interface X will be named X_, X_en,
	// X_en_CA, etc.
	GwtLocale generatedLocale = resourceList.findLeastDerivedLocale(logger,
	locale);
	String localeSuffix = String.valueOf(ResourceFactory.LOCALE_SEPARATOR);
	localeSuffix += generatedLocale.getAsString();
	// Use _ rather than "." in class name, cannot use $
	String resourceName = targetClass.getName().replace('.', '_');
	String className = resourceName + localeSuffix;
	PrintWriter pw = context.tryCreate(logger, packageName, className);
	if (pw != null) {
	ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(
	packageName, className);
	factory.addImplementedInterface(targetClass.getQualifiedSourceName());
	SourceWriter writer = factory.createSourceWriter(context, pw);
	// Now that we have all the information set up, process the class
	if (constantsWithLookupClass.isAssignableFrom(targetClass)) {
	ConstantsWithLookupImplCreator c = new ConstantsWithLookupImplCreator(
	logger, writer, targetClass, resourceList, context.getTypeOracle());
	c.emitClass(logger, generatedLocale);
	} else if (constantsClass.isAssignableFrom(targetClass)) {
	ConstantsImplCreator c = new ConstantsImplCreator(logger, writer,
	targetClass, resourceList, context.getTypeOracle());
	c.emitClass(logger, generatedLocale);
	} else {
	MessagesImplCreator messages = new MessagesImplCreator(logger, writer,
	targetClass, resourceList, context.getTypeOracle());
	messages.emitClass(logger, generatedLocale);
	}
	context.commit(logger, pw);
	}
	// Generate a translatable output file if requested.
	Generate generate = getClassAnnotation(targetClass, Generate.class);
	if (generate != null) {
	String path = generate.fileName();
	if (Generate.DEFAULT.equals(path)) {
	path = targetClass.getPackage().getName() + "."
	+ targetClass.getName().replace('.', '_');
	} else if (path.endsWith(File.pathSeparator)) {
	path = path + targetClass.getName().replace('.', '_');
	}
	String[] genLocales = generate.locales();
	boolean found = false;
	if (genLocales.length != 0) {
	// verify the current locale is in the list
	for (String genLocale : genLocales) {
	if (GwtLocale.DEFAULT_LOCALE.equals(genLocale)) {
	// Locale "default" gets special handling because of property
	// fallbacks; "default" might be mapped to any real locale.
	try {
	SelectionProperty localeProp = context.getPropertyOracle()
	.getSelectionProperty(logger, "locale");
	String defaultLocale = localeProp.getFallbackValue();
	if (defaultLocale.length() > 0) {
	genLocale = defaultLocale;
	}
	} catch (BadPropertyValueException e) {
	throw error(logger, "Could not get 'locale' property");
	}
	}
	if (genLocale.equals(locale.toString())) {
	found = true;
	break;
	}
	}
	} else {
	// Since they want all locales, this is guaranteed to be one of them.
	found = true;
	}
	if (found) {
	for (String genClassName : generate.format()) {
	MessageCatalogFormat msgWriter = null;
	MessageCatalogFactory msgCatFactory = null;
	try {
	// TODO(jat): if GWT is ever modified to take a classpath for user
	// code as an option, we would need to use the user classloader here
	Class<?> clazz = Class.forName(genClassName, false,
	MessageCatalogFormat.class.getClassLoader());
	if (MessageCatalogFormat.class.isAssignableFrom(clazz)) {
	Class<? extends MessageCatalogFormat> msgFormatClass
	= clazz.asSubclass(MessageCatalogFormat.class);
	msgWriter = msgFormatClass.newInstance();
	} else if (MessageCatalogFactory.class.isAssignableFrom(clazz)) {
	Class<? extends MessageCatalogFactory> msgFactoryClass
	= clazz.asSubclass(MessageCatalogFactory.class);
	msgCatFactory = msgFactoryClass.newInstance();
	} else {
	logger.log(TreeLogger.ERROR, "Class specified in @Generate must "
	+ "either be a subtype of MessageCatalogFormat or "
	+ "MessageCatalogFactory");
	seenError = true;
	continue;
	}
	} catch (InstantiationException e) {
	logger.log(TreeLogger.ERROR, "Error instantiating @Generate class "
	+ genClassName, e);
	seenError = true;
	continue;
	} catch (IllegalAccessException e) {
	logger.log(TreeLogger.ERROR, "@Generate class " + genClassName
	+ " illegal access", e);
	seenError = true;
	continue;
	} catch (ClassNotFoundException e) {
	logger.log(TreeLogger.ERROR, "@Generate class " + genClassName
	+ " not found");
	seenError = true;
	continue;
	}
	// Make generator-specific changes to a temporary copy of the path.
	String genPath = path;
	if (genLocales.length != 1) {
	// If the user explicitly specified only one locale, do not add the
	// locale.
	genPath += '_' + locale.toString();
	}
	if (msgCatFactory != null) {
	seenError \|= generateToMsgCatFactory(logger, context, locale,
	targetClass, seenError, resourceList, msgCatFactory, genPath);
	} else if (msgWriter != null) {
	seenError \|= generateToLegacyMsgCatFormat(logger, context, locale,
	targetClass, seenError, resourceList, className, msgWriter,
	genPath);
	}
	}
	}
	}
	if (seenError) {
	// If one of our generators had a fatal error, don't complete normally.
	throw new UnableToCompleteException();
	}
	return packageName + "." + className;
	}

	/**
	* Write translation source files to the old-style
	* {@link MessageCatalogFormat}.
	*
	* @param logger
	* @param context
	* @param locale
	* @param targetClass
	* @param seenError
	* @param resourceList
	* @param className
	* @param msgWriter
	* @param genPath
	* @return true if an error occurred (already logged)
	* @throws UnableToCompleteException
	*/

	private static boolean generateToLegacyMsgCatFormat(TreeLogger logger,
	GeneratorContext context, GwtLocale locale, JClassType targetClass,
	boolean seenError, ResourceList resourceList, String className,
	MessageCatalogFormat msgWriter, String genPath)
	throws UnableToCompleteException {
	genPath += msgWriter.getExtension();
	OutputStream outStr = context.tryCreateResource(logger, genPath);
	if (outStr != null) {
	TreeLogger branch = logger.branch(TreeLogger.TRACE, "Generating "
	+ genPath + " from " + className + " for locale " + locale,
	null);
	PrintWriter out = null;
	try {
	out = new PrintWriter(new BufferedWriter(
	new OutputStreamWriter(outStr, "UTF-8")), false);
	} catch (UnsupportedEncodingException e) {
	throw error(logger, "UTF-8 not supported", e);
	}
	try {
	msgWriter.write(branch, locale.toString(), resourceList, out,
	targetClass);
	out.flush();
	context.commitResource(logger, outStr).setVisibility(
	Visibility.Private);
	} catch (UnableToCompleteException e) {
	// msgWriter should have already logged an error message.
	// Keep going for now so we can find other errors.
	seenError = true;
	}
	}
	return seenError;
	}

	/**
	* Write translation source files to a {@link MessageCatalogFactory}.
	*
	* @param logger
	* @param context
	* @param locale
	* @param targetClass
	* @param seenError
	* @param resourceList
	* @param msgCatFactory
	* @param genPath
	* @return true if an error occurred (already logged)
	*/
	private static boolean generateToMsgCatFactory(TreeLogger logger,
	GeneratorContext context, GwtLocale locale, JClassType targetClass, boolean seenError,
	ResourceList resourceList, MessageCatalogFactory msgCatFactory,
	String genPath) {
	// TODO(jat): maintain MessageCatalogWriter instances across
	// generator runs so they can save state. One problem is knowing
	// when the last generator has been run.
	Writer catWriter = null;
	try {
	String catalogName = genPath + msgCatFactory.getExtension();
	Context ctx = new MessageCatalogContextImpl(
	context, logger);
	MessageInterface msgIntf = new TypeOracleMessageInterface(
	LocaleUtils.getLocaleFactory(), targetClass, resourceList);
	catWriter = msgCatFactory.getWriter(ctx, catalogName);
	if (catWriter == null) {
	if (logger.isLoggable(TreeLogger.TRACE)) {
	logger.log(TreeLogger.TRACE, "Already generated " + catalogName);
	}
	return false;
	}
	msgIntf.accept(catWriter.visitClass());
	} catch (MessageProcessingException e) {
	logger.log(TreeLogger.ERROR, e.getMessage(), e);
	seenError = true;
	} finally {
	if (catWriter != null) {
	try {
	catWriter.close();
	} catch (IOException e) {
	logger.log(TreeLogger.ERROR,
	"IO error closing catalog writer", e);
	seenError = true;
	}
	}
	}
	return seenError;
	}

	/**
	* Generator to use to create keys for messages.
	*/
	private KeyGenerator keyGenerator;

	/**
	* The Dictionary/value bindings used to determine message contents.
	*/
	private ResourceList resourceList;

	/**
	* True if the class being generated uses Constants-style annotations/quoting.
	*/
	private boolean isConstants;

	/**
	* Constructor for <code>AbstractLocalizableImplCreator</code>.
	*
	* @param writer writer
	* @param targetClass current target
	* @param resourceList backing resource
	*/
	public AbstractLocalizableImplCreator(TreeLogger logger, SourceWriter writer,
	JClassType targetClass, ResourceList resourceList, boolean isConstants) {
	super(writer, targetClass);
	this.resourceList = resourceList;
	this.isConstants = isConstants;
	try {
	keyGenerator = AnnotationsResource.getKeyGenerator(targetClass);
	} catch (AnnotationsError e) {
	logger.log(TreeLogger.WARN, "Error getting key generator for "
	+ targetClass.getQualifiedSourceName(), e);
	}
	}

	/**
	* Gets the resource associated with this class.
	*
	* @return the resource
	*/
	public ResourceList getResourceBundle() {
	return resourceList;
	}

	@Override
	protected String branchMessage() {
	return "Processing " + this.getTarget();
	}

	/**
	* Find the creator associated with the given method, and delegate the
	* creation of the method body to it.
	*
	* @param logger TreeLogger instance for logging
	* @param method method to be generated
	* @param locale locale to generate
	* @throws UnableToCompleteException
	*/
	protected void delegateToCreator(TreeLogger logger, JMethod method,
	GwtLocale locale) throws UnableToCompleteException {
	AbstractMethodCreator methodCreator = getMethodCreator(logger, method);
	String key = getKey(logger, method);
	if (key == null) {
	logger.log(TreeLogger.ERROR, "Unable to get or compute key for method "
	+ method.getName(), null);
	throw new UnableToCompleteException();
	}
	methodCreator.createMethodFor(logger, method, key, resourceList, locale);
	}

	/**
	* Returns a resource key given a method name.
	*
	* @param logger TreeLogger instance for logging
	* @param method method to get key for
	* @return the key to use for resource lookups or null if unable to get or
	* compute the key
	*/
	protected String getKey(TreeLogger logger, JMethod method) {
	Key key = method.getAnnotation(Key.class);
	if (key != null) {
	return key.value();
	}
	return AnnotationsResource.getKey(logger, keyGenerator, method, isConstants);
	}
	}