<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>

<head>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   <meta name="Build" content="Build">
   <title>Eclipse Platform Release Notes (3.3) - JDT Annotation Processing</title>
</head>

<body>

<h1>Eclipse Platform Build Notes (3.3)<br>
JDT Annotation Processing</h1>

<p>Integration Build (August 20, 2007, 4:03 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=188559">Bug 188559</a>. Delete files generated by Java 6 processors during build (NEW)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=190617">Bug 190617</a>. [jsr269] processors not getting called on final round (ASSIGNED)<br>
  </p>

<p>Integration Build (July 23, 2007, 3:16 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=190268">Bug 190268</a>. Need to perform a validateEdit() before setting encoding (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=193784">Bug 193784</a>. Proprietary licenses (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=197050">Bug 197050</a>. [jsr269]  Support -XprintRounds and -XprintProcessorInfo (FIXED)<br>
  </p>

<p>Integration Build (May 23, 2007, 9:07 a.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=186427">Bug 186427</a>. Need a finally block in AptDispatchRunnable.build (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=187135">Bug 187135</a>. AbortCompilationException when project is missing classes (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=188185">Bug 188185</a>. RTTG_ENABLED_OPTION should ignore -A (FIXED)<br>
  </p>

<p>Integration Build (May 14, 2007, 6:20 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=171893">Bug 171893</a>. getPackage().getQualifiedName() is slow (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=186740">Bug 186740</a>. [PERF] discard cached Problems after each build (FIXED)<br>
  </p>

<p>Integration Build (May 10, 2007, 5:05 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=178138">Bug 178138</a>. APT writes to the log when a factory path entry is missing (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181869">Bug 181869</a>. IllegalArgumentException with annotation value syntax error (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=182364">Bug 182364</a>. Type checking is too aggressive (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185220">Bug 185220</a>. IDE java 6 APT support needs a Messager (FIXED)<br>
  </p>

<p>Integration Build (May 02, 2007, 12:55 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=184923">Bug 184923</a>. Deadlock in AnnotationProcessorFactoryLoader (FIXED)<br>
  </p>

<p>Integration Build (May 01, 2007, 5:57 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=178690">Bug 178690</a>. Processors should be able to disable reconcile-time type deletion (NEW)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185010">Bug 185010</a>. Catch processor exceptions lower on the stack during reconcile (NEW)<br>
  </p>

<p>Integration Build (April 16, 2007, 7:16 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
  </p>

<p>Integration Build (April 09, 2007, 6:36 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=180595">Bug 180595</a>. Permit modification of AnnotationProcessorListeners during callback (FIXED)<br>
  </p>

<p>Integration Build (April 02, 2007, 5:59 p.m.)</p>
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=175794">Bug 175794</a>. Type generation causes reported problems to disappear (ASSIGNED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=177683">Bug 177683</a>. NPE in internal.util.Factory.createErrorClassType() (FIXED)<br>
  </p>

<p>Integration Build (March 19, 2007, 00:10)</p>
  <p>Java 6 annotation processing</p>
  <p>
In this integration build, the Java 6 annotation processing API (JSR-269) has been partly enabled.  Not all aspects of the API are yet working.
If you have specific use cases that need to be supported before you can to contribute testing, please feel free to enter bug reports
against the JDT APT component, or email jdt-apt-dev@eclipse.org.  Please provide as much detail as possible.
  </p>
  
  <p>Problem reports updated</p>
  <p>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=176883">Bug 176883</a>. Deleted files not being properly reported (FIXED)<br>
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=176132">Bug 176132</a>. Add a flag to disable reconcile-time annotation processing (FIXED)<br>
  </p>