Add ElementVisitor implementations and JavaFileManager forwarder.

2013-02-18  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* javax/annotation/processing/SupportedSourceVersion.java:
	Implemented.
	(value()): Implemented.
	* javax/lang/model/element/ElementVisitor.java:
	Fix typo: "implementators" should be "implementors".
	* javax/lang/model/element/UnknownElementException.java:
	(UnknownElementException(Element,Object)): Set message
	using superclass constructor.
	* javax/lang/model/util/AbstractElementVisitor6.java:
	Implemented.
	(AbstractElementVisitor6()): Implemented.
	(visit(Element)): Likewise.
	(visit(Element,P)): Likewise.
	(visitUnknown(Element,P)): Likewise.
	* javax/lang/model/util/ElementScanner6.java:
	Implemented.
	(ElementScanner6()): Implemented.
	(ElementScanner6(R)): Likewise.
	(scan(Element)): Likewise.
	(scan(Element, P)): Likewise.
	(scan(Iterable, P)): Likewise.
	(visitExecutable(ExecutableElement, P)): Likewise.
	(visitPackage(PackageElement, P)): Likewise.
	(visitType(TypeElement, P)): Likewise.
	(visitTypeParameter(TypeElement, P)): Likewise.
	(visitVariable(VariableElement, P)): Likewise.
	* javax/lang/model/util/SimpleElementVisitor6.java,
	Implemented.
	(DEFAULT_VALUE): Added.
	(SimpleElementVisitor6()): Implemented.
	(SimpleElementVisitor6(R)): Likewise.
	(defaultAction(Element, P)): Likewise.
	(visitExecutable(ExecutableElement, P)): Likewise.
	(visitPackage(PackageElement, P)): Likewise.
	(visitType(TypeElement, P)): Likewise.
	(visitTypeParameter(TypeElement, P)): Likewise.
	(visitVariable(VariableElement, P)): Likewise.
	* javax/tools/ForwardingJavaFileManager.java:
	Implemented.
	(fileManager): Added.
	(ForwardingJavaFileManager(M)): Implemented.
	(close()): Likewise.
	(flush()): Likewise.
	(getClassLoader(JavaFileManager.Location)): Likewise.
	(getFileForInput(JavaFileManager.Location, String,
	String)): Likewise.
	(getFileForOutput(JavaFileManager.Location, String,
	String, FileObject)): Likewise.
	(getJavaFileForInput(JavaFileManager.Location, String,
	JavaFileObject.Kind)): Likewise.
	(getJavaFileForOutput(JavaFileManager.Location, String,
	JavaFileObject.Kind, FileObject)): Likewise.
	(handleOption(String,Iterator)): Likewise.
	(hasLocation(JavaFileManager.Location)): Likewise.
	(inferBinaryName(JavaFileManager.Location, JavaFileObject)):
	Likewise.
	(isSameFile(FileObject, FileObject)): Likewise.
	(isSupportedOption(String)): Likewise.
	(list(JavaFileManager.Location, String, Set, boolean)):
	Likewise.

Signed-off-by: Andrew John Hughes <gnu_andrew@member.fsf.org>

8 files changed, 875 insertions, 1 deletions

diff --git a/ChangeLog b/ChangeLog
index eaa30563f..c5bb0454b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,66 @@
+2013-02-18  Andrew John Hughes  <gnu_andrew@member.fsf.org>
+
+	* javax/annotation/processing/SupportedSourceVersion.java:
+	Implemented.
+	(value()): Implemented.
+	* javax/lang/model/element/ElementVisitor.java:
+	Fix typo: "implementators" should be "implementors".
+	* javax/lang/model/element/UnknownElementException.java:
+	(UnknownElementException(Element,Object)): Set message
+	using superclass constructor.
+	* javax/lang/model/util/AbstractElementVisitor6.java:
+	Implemented.
+	(AbstractElementVisitor6()): Implemented.
+	(visit(Element)): Likewise.
+	(visit(Element,P)): Likewise.
+	(visitUnknown(Element,P)): Likewise.
+	* javax/lang/model/util/ElementScanner6.java:
+	Implemented.
+	(ElementScanner6()): Implemented.
+	(ElementScanner6(R)): Likewise.
+	(scan(Element)): Likewise.
+	(scan(Element, P)): Likewise.
+	(scan(Iterable, P)): Likewise.
+	(visitExecutable(ExecutableElement, P)): Likewise.
+	(visitPackage(PackageElement, P)): Likewise.
+	(visitType(TypeElement, P)): Likewise.
+	(visitTypeParameter(TypeElement, P)): Likewise.
+	(visitVariable(VariableElement, P)): Likewise.
+	* javax/lang/model/util/SimpleElementVisitor6.java,
+	Implemented.
+	(DEFAULT_VALUE): Added.
+	(SimpleElementVisitor6()): Implemented.
+	(SimpleElementVisitor6(R)): Likewise.
+	(defaultAction(Element, P)): Likewise.
+	(visitExecutable(ExecutableElement, P)): Likewise.
+	(visitPackage(PackageElement, P)): Likewise.
+	(visitType(TypeElement, P)): Likewise.
+	(visitTypeParameter(TypeElement, P)): Likewise.
+	(visitVariable(VariableElement, P)): Likewise.
+	* javax/tools/ForwardingJavaFileManager.java:
+	Implemented.
+	(fileManager): Added.
+	(ForwardingJavaFileManager(M)): Implemented.
+	(close()): Likewise.
+	(flush()): Likewise.
+	(getClassLoader(JavaFileManager.Location)): Likewise.
+	(getFileForInput(JavaFileManager.Location, String,
+	String)): Likewise.
+	(getFileForOutput(JavaFileManager.Location, String,
+	String, FileObject)): Likewise.
+	(getJavaFileForInput(JavaFileManager.Location, String,
+	JavaFileObject.Kind)): Likewise.
+	(getJavaFileForOutput(JavaFileManager.Location, String,
+	JavaFileObject.Kind, FileObject)): Likewise.
+	(handleOption(String,Iterator)): Likewise.
+	(hasLocation(JavaFileManager.Location)): Likewise.
+	(inferBinaryName(JavaFileManager.Location, JavaFileObject)):
+	Likewise.
+	(isSameFile(FileObject, FileObject)): Likewise.
+	(isSupportedOption(String)): Likewise.
+	(list(JavaFileManager.Location, String, Set, boolean)):
+	Likewise.
+
 2013-02-03  Andrew John Hughes  <gnu_andrew@member.fsf.org>
 
 	* javax/lang/model/util/ElementFilter.java:
diff --git a/javax/annotation/processing/SupportedSourceVersion.java b/javax/annotation/processing/SupportedSourceVersion.java
new file mode 100644
index 000000000..a5bde9642
--- /dev/null
+++ b/javax/annotation/processing/SupportedSourceVersion.java
@@ -0,0 +1,61 @@
+/* SupportedSourceVersion.java -- Annotation to indicate supported source version.
+   Copyright (C) 2013  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.annotation.processing;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.lang.model.SourceVersion;
+
+/**
+ * Indicates the latest source version supported.
+ * This can be used by {@link Processor#getSupportedSourceVersion()}
+ * to obtain the supported source version automatically.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.6
+ */
+@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE)
+public @interface SupportedSourceVersion
+{
+  /** The language source version supported. */
+  SourceVersion value();
+}
diff --git a/javax/lang/model/element/ElementVisitor.java b/javax/lang/model/element/ElementVisitor.java
index 133ab5aa5..4b5a66105 100644
--- a/javax/lang/model/element/ElementVisitor.java
+++ b/javax/lang/model/element/ElementVisitor.java
@@ -48,7 +48,7 @@ package javax.lang.model.element;
  * {@code NullPointerException} if {@code null} is passed as the
  * additional parameter.</p>
  * <p>As this interface may be extended to accomodate future language
- * versions, implementators are encouraged to extend one of the
+ * versions, implementors are encouraged to extend one of the
  * appropriate abstract classes rather than implementating this
  * interface.  However, this interface should be used as the type
  * for parameters and return values.</p>
diff --git a/javax/lang/model/element/UnknownElementException.java b/javax/lang/model/element/UnknownElementException.java
index cdf5f1877..68391b275 100644
--- a/javax/lang/model/element/UnknownElementException.java
+++ b/javax/lang/model/element/UnknownElementException.java
@@ -73,6 +73,7 @@ public class UnknownElementException
    */
   public UnknownElementException(Element element, Object param)
   {
+    super("The element " + element + " is not recognised,");
     this.element = element;
     this.param = param;
   }
diff --git a/javax/lang/model/util/AbstractElementVisitor6.java b/javax/lang/model/util/AbstractElementVisitor6.java
new file mode 100644
index 000000000..84463ff18
--- /dev/null
+++ b/javax/lang/model/util/AbstractElementVisitor6.java
@@ -0,0 +1,127 @@
+/* AbstractElementVisitor6.java -- A visitor of program elements for 1.6.
+   Copyright (C) 2013  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.lang.model.util;
+
+import javax.annotation.processing.SupportedSourceVersion;
+
+import javax.lang.model.SourceVersion;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementVisitor;
+import javax.lang.model.element.UnknownElementException;
+
+/**
+ * <p>A skeletal implementation of {@link ElementVisitor} for the
+ * 1.6 version of the Java programming language
+ * ({@link SourceVersion#RELEASE_6}).  Implementors can extend this
+ * class and need provide only implementations of the
+ * {@code visitXYZ} methods appropriate to 1.6.</p>
+ * <p>As the interface this class implements may be extended in future,
+ * in order to support later language versions, methods beginning with
+ * the phrase {@code "visit"} should be avoided in subclasses.  This
+ * class itself will be extended to direct these new methods to the
+ * {@link #visitUnknown(Element,P) method and a new class will be
+ * added to provide implementations for the new language version.
+ * At this time, all or some of this class may be deprecated.</p>
+ *
+ * @param <R> the return type of the visitor's methods.  {@code Void}
+ *            can be used where there is no return value.
+ * @param <P> the type of the additional parameter supplied to the visitor's
+ *            methods.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.6
+ */
+@SupportedSourceVersion(SourceVersion.RELEASE_6)
+public abstract class AbstractElementVisitor6<R,P> implements ElementVisitor<R,P>
+{
+
+  /**
+   * Constructs a new {@code AbstractElementVisitor6}.
+   */
+  protected AbstractElementVisitor6() {}
+
+  /**
+   * Visits a program element by passing itself to the element's
+   * {@code accept} method and {@code null} for the additional
+   * parameter i.e. {@code{v.visit(element)} is equivalent to 
+   * {@code{element.accept(v, null)}.
+   *
+   * @param element the element to visit.
+   * @return the return value specific to the element.
+   */
+  @Override
+  public final R visit(Element element)
+  {
+    return element.accept(this, null);
+  }
+
+  /**
+   * Visits a program element by passing itself to the element's
+   * {@code accept} method and the specified value as the additional
+   * parameter i.e. {@code{v.visit(element, parameter)} is equivalent to 
+   * {@code{element.accept(v, parameter)}.
+   *
+   * @param element the element to visit.
+   * @param parameter the value to use as the additional parameter.
+   * @return the return value specific to the element.
+   */
+  @Override
+  public final R visit(Element element, P parameter)
+  {
+    return element.accept(this, parameter);
+  }
+
+  /**
+   * Visits an unknown element.  This method is called if
+   * this visitor is used in a version of the language later
+   * than 1.6, where new elements have been added.  This
+   * implementation always throws a {@link UnknownElementException}
+   * but this is not required of subclasses.
+   *
+   * @param element the element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   * @return the return value specific to the visitor.
+   * @throws UnknownElementException by default.
+   */
+  public R visitUnknown(Element element, P parameter)
+  {
+    throw new UnknownElementException(element, parameter);
+  }
+
+}
diff --git a/javax/lang/model/util/ElementScanner6.java b/javax/lang/model/util/ElementScanner6.java
new file mode 100644
index 000000000..ef3f0cc61
--- /dev/null
+++ b/javax/lang/model/util/ElementScanner6.java
@@ -0,0 +1,223 @@
+/* ElementScanner6.java -- A scanning visitor of program elements for 1.6.
+   Copyright (C) 2013  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.lang.model.util;
+
+import javax.annotation.processing.SupportedSourceVersion;
+
+import javax.lang.model.SourceVersion;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementVisitor;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.element.VariableElement;
+
+/**
+ * <p>A scanning implementation of {@link ElementVisitor} for the
+ * 1.6 version of the Java programming language
+ * ({@link SourceVersion#RELEASE_6}).  Each {@code visitXYZ} method
+ * calls {@link scan(Element)} on the elements enclosed within the
+ * one it receives as an argument.  Implementors may extend this
+ * class and provide alternative implementations of the {@code visitXYZ}
+ * methods appropriate, so that scanning takes place in a different
+ * order.</p>
+ * <p>As the interface this class implements may be extended in future,
+ * in order to support later language versions, methods beginning with
+ * the phrase {@code "visit"} should be avoided in subclasses.  This
+ * class itself will be extended to direct these new methods to the
+ * {@link #visitUnknown(Element,P) method and a new class will be
+ * added to provide implementations for the new language version.
+ * At this time, all or some of this class may be deprecated.</p>
+ * 
+ * @param <R> the return type of the visitor's methods.  {@code Void}
+ *            can be used where there is no return value.
+ * @param <P> the type of the additional parameter supplied to the visitor's
+ *            methods.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.6
+ */
+@SupportedSourceVersion(SourceVersion.RELEASE_6)
+public class ElementScanner6<R,P> extends AbstractElementVisitor6<R,P>
+{
+
+  /** The default return value when no elements are scanned. */
+  protected final R DEFAULT_VALUE;
+
+  /**
+   * Constructs a new {@code ElementScanner6} using {@code null}
+   * as the default value.
+   */
+  protected ElementScanner6()
+  {
+    this(null);
+  }
+
+  /**
+   * Constructs a new {@code ElementScanner6} using the specified
+   * default value.
+   *
+   * @param defaultValue the default value to return when there
+   *                     no elements to scan.
+   */
+  protected ElementScanner6(R defaultValue)
+  {
+    super();
+    DEFAULT_VALUE = defaultValue;
+  }
+
+  /**
+   * Convenience method to simplify calls with no parameter.
+   * This is equivalent to {@code v.scan(element, null)}.
+   *
+   * @param element the element to scan.
+   * @return the result of scanning the element.
+   */
+  public final R scan(Element element)
+  {
+    return scan(element, null);
+  }
+
+  /**
+   * Scans a single element by calling {@code element.accept(this, parameter)}.
+   * Subclasses may override this to provide different behaviour.
+   *
+   * @param element the element to scan.
+   * @param parameter the value to use as the additional parameter.
+   * @return the result of scanning the element.
+   */
+  public R scan(Element element, P parameter)
+  {
+    return element.accept(this, parameter);
+  }
+
+  /**
+   * Scans a series of elements by iterating over them and calling
+   * {@code scan(element, parameter)}.  The result returned is that
+   * of the last call or {@code DEFAULT_VALUE} if the iterable is
+   * empty.
+   *
+   * @param elements the elements to scan.
+   * @param parameter the value to use as the additional parameter.
+   * @return the result of scanning the last element or
+   *         {@code DEFAULT_VALUE} if there are none.
+   */
+  public final R scan(Iterable<? extends Element> elements, P parameter)
+  {
+    R result = DEFAULT_VALUE;
+    for (Element element : elements)
+    {
+      result = scan(element, parameter);
+    }
+    return result;
+  }
+
+  /**
+   * Visits an executable element.  This implementation scans the
+   * parameters.
+   *
+   * @param element the executable element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitExecutable(ExecutableElement element, P parameter)
+  {
+    return scan(element.getParameters(), parameter);
+  }
+
+
+  /**
+   * Visits a package element.  This implementation scans the
+   * enclosed elements.
+   *
+   * @param element the package element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitPackage(PackageElement element, P parameter)
+  {
+    return scan(element.getEnclosedElements(), parameter);
+  }
+
+  /**
+   * Visits a type element.  This implementation scans the
+   * enclosed elements.
+   *
+   * @param element the type element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitType(TypeElement element, P parameter)
+  {
+    return scan(element.getEnclosedElements(), parameter);
+  }
+
+  /**
+   * Visits a type parameter element.  This implementation scans the
+   * enclosed elements.
+   *
+   * @param element the type parameter element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitTypeParameter(TypeParameterElement element, P parameter)
+  {
+    return scan(element.getEnclosedElements(), parameter);
+  }
+
+  /**
+   * Visits a variable element.  This implementation scans the
+   * enclosed elements.
+   *
+   * @param element the variable element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitVariable(VariableElement element, P parameter)
+  {
+    return scan(element.getEnclosedElements(), parameter);
+  }
+
+}
diff --git a/javax/lang/model/util/SimpleElementVisitor6.java b/javax/lang/model/util/SimpleElementVisitor6.java
new file mode 100644
index 000000000..21cac478b
--- /dev/null
+++ b/javax/lang/model/util/SimpleElementVisitor6.java
@@ -0,0 +1,191 @@
+/* SimpleElementVisitor6.java -- A simple visitor implementation for 1.6.
+   Copyright (C) 2013  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.lang.model.util;
+
+import javax.annotation.processing.SupportedSourceVersion;
+
+import javax.lang.model.SourceVersion;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementVisitor;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.element.VariableElement;
+
+/**
+ * <p>A simple implementation of {@link ElementVisitor} for the
+ * 1.6 version of the Java programming language
+ * ({@link SourceVersion#RELEASE_6}).  Each {@code visitXYZ} method
+ * redirects to {@code defaultAction(element, parameter)}.
+ * Implementors may extend this class and provide alternative
+ * implementations of {@link #defaultAction(Element, P)} and
+ * the {@code visitXYZ} methods as appropriate.</p>
+ * <p>As the interface this class implements may be extended in future,
+ * in order to support later language versions, methods beginning with
+ * the phrase {@code "visit"} should be avoided in subclasses.  This
+ * class itself will be extended to direct these new methods to the
+ * {@link #visitUnknown(Element,P) method and a new class will be
+ * added to provide implementations for the new language version.
+ * At this time, all or some of this class may be deprecated.</p>
+ * 
+ * @param <R> the return type of the visitor's methods.  {@code Void}
+ *            can be used where there is no return value.
+ * @param <P> the type of the additional parameter supplied to the visitor's
+ *            methods.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.6
+ */
+@SupportedSourceVersion(SourceVersion.RELEASE_6)
+public class SimpleElementVisitor6<R,P> extends AbstractElementVisitor6<R,P>
+{
+
+  /**
+   * The default value returned by calls to {@link #defaultAction(Element, P)}.
+   */
+  protected final R DEFAULT_VALUE;
+
+  /**
+   * Constructs a new {@link SimpleElementVisitor6} with a {@code null}
+   * default value.
+   */
+  protected SimpleElementVisitor6()
+  {
+    this(null);
+  }
+
+  /**
+   * Constructs a new {@link SimpleElementVisitor6} with the specified
+   * default value.
+   *
+   * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}.
+   */
+  protected SimpleElementVisitor6(R defaultValue)
+  {
+    DEFAULT_VALUE = defaultValue;
+  }
+
+  /**
+   * The default action for all visitor methods.  The default implementation
+   * simply returns {@link #DEFAULT_VALUE}.
+   *
+   * @param element the element to act upon.
+   * @param parameter the optional parameter supplied to the visitor.
+   * @return {@link #DEFAULT_VALUE}.
+   */
+  protected R defaultAction(Element element, P parameter)
+  {
+    return DEFAULT_VALUE;
+  }
+
+  /**
+   * Visits an executable element.  This implementation simply
+   * calls {@code defaultAction(element, parameter)}.
+   *
+   * @param element the executable element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitExecutable(ExecutableElement element, P parameter)
+  {
+    return defaultAction(element, parameter);
+  }
+
+
+  /**
+   * Visits a package element.  This implementation simply
+   * calls {@code defaultAction(element, parameter)}.
+   *
+   * @param element the package element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitPackage(PackageElement element, P parameter)
+  {
+    return defaultAction(element, parameter);
+  }
+
+  /**
+   * Visits a type element.  This implementation simply
+   * calls {@code defaultAction(element, parameter)}.
+   *
+   * @param element the type element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitType(TypeElement element, P parameter)
+  {
+    return defaultAction(element, parameter);
+  }
+
+  /**
+   * Visits a type parameter element.  This implementation simply
+   * calls {@code defaultAction(element, parameter)}.
+   *
+   * @param element the type parameter element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitTypeParameter(TypeParameterElement element, P parameter)
+  {
+    return defaultAction(element, parameter);
+  }
+
+  /**
+   * Visits a variable element.  This implementation simply
+   * calls {@code defaultAction(element, parameter)}.
+   *
+   * @param element the variable element to visit.
+   * @param parameter the additional parameter, specific to the visitor.
+   *        May be {@code null}.
+   */
+  @Override
+  public R visitVariable(VariableElement element, P parameter)
+  {
+    return defaultAction(element, parameter);
+  }
+
+}
+
+  
diff --git a/javax/tools/ForwardingJavaFileManager.java b/javax/tools/ForwardingJavaFileManager.java
new file mode 100644
index 000000000..561a71848
--- /dev/null
+++ b/javax/tools/ForwardingJavaFileManager.java
@@ -0,0 +1,208 @@
+/* ForwardingFileManager.java -- File manager that forwards to another.
+   Copyright (C) 2013  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.tools;
+
+import java.io.IOException;
+
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * Forwards calls to a specified file manager.
+ *
+ * @param <M> the kind of file manager calls are forwarded to.
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.6
+ */
+public class ForwardingJavaFileManager<M extends JavaFileManager>
+  implements JavaFileManager
+{
+
+  /**
+   * The file manager to delegate to.
+   */
+  protected M fileManager;
+
+  /**
+   * Creates a new forwarder, delegating calls to the
+   * specified file manager.
+   *
+   * @param manager the manager to forward calls to.
+   */
+  protected ForwardingJavaFileManager(M manager)
+  {
+    fileManager = manager;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public void close() throws IOException
+  {
+    fileManager.close();
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public void flush() throws IOException
+  {
+    fileManager.flush();
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public ClassLoader getClassLoader(JavaFileManager.Location loc)
+  {
+    return fileManager.getClassLoader(loc);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public FileObject getFileForInput(JavaFileManager.Location loc,
+				    String pkgName, String relativeName)
+    throws IOException
+  {
+    return fileManager.getFileForInput(loc, pkgName, relativeName);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public FileObject getFileForOutput(JavaFileManager.Location loc,
+				     String pkgName, String relativeName,
+				     FileObject sibling)
+    throws IOException
+  {
+    return fileManager.getFileForOutput(loc, pkgName, relativeName,
+					sibling);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public JavaFileObject getJavaFileForInput(JavaFileManager.Location loc,
+					    String className,
+					    JavaFileObject.Kind kind)
+    throws IOException
+  {
+    return fileManager.getJavaFileForInput(loc, className, kind);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public JavaFileObject getJavaFileForOutput(JavaFileManager.Location loc,
+					     String className,
+					     JavaFileObject.Kind kind,
+					     FileObject sibling)
+    throws IOException
+  {
+    return fileManager.getJavaFileForOutput(loc, className, kind,
+					    sibling);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public boolean handleOption(String current, Iterator<String> remaining)
+  {
+    return fileManager.handleOption(current, remaining);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public boolean hasLocation(JavaFileManager.Location loc)
+  {
+    return fileManager.hasLocation(loc);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public String inferBinaryName(JavaFileManager.Location loc,
+				JavaFileObject fileObj)
+  {
+    return fileManager.inferBinaryName(loc, fileObj);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public boolean isSameFile(FileObject a, FileObject b)
+  {
+    return fileManager.isSameFile(a, b);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public int isSupportedOption(String option)
+  {
+    return fileManager.isSupportedOption(option);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  @Override
+  public Iterable<JavaFileObject> list(JavaFileManager.Location loc,
+				       String pkgName,
+				       Set<JavaFileObject.Kind> kinds,
+				       boolean recurse)
+    throws IOException
+  {
+    return fileManager.list(loc, pkgName, kinds, recurse);
+  }
+
+}