--- a/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Tue Mar 29 16:41:18 2011 +0100
+++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Wed Mar 30 18:18:11 2011 -0700
@@ -1162,6 +1162,9 @@
         ClassSymbol c = readClassSymbol(nextChar());
         NameAndType nt = (NameAndType)readPool(nextChar());
 
+        if (c.members_field == null)
+            throw badClassFile("bad.enclosing.class", self, c);
+
         MethodSymbol m = findMethod(nt, c.members_field, self.flags());
         if (nt != null && m == null)
             throw badClassFile("bad.enclosing.method", self);

--- a/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Tue Mar 29 16:41:18 2011 +0100
+++ b/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Wed Mar 30 18:18:11 2011 -0700
@@ -58,6 +58,7 @@
 import com.sun.tools.javac.file.FSInfo;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.jvm.*;
+import com.sun.tools.javac.jvm.ClassReader.BadClassFile;
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.main.JavaCompiler.CompileState;
 import com.sun.tools.javac.model.JavacElements;
@@ -790,6 +791,9 @@
                                          RoundEnvironment renv) {
         try {
             return proc.process(tes, renv);
+        } catch (BadClassFile ex) {
+            log.error("proc.cant.access.1", ex.sym, ex.getDetailValue());
+            return false;
         } catch (CompletionFailure ex) {
             StringWriter out = new StringWriter();
             ex.printStackTrace(new PrintWriter(out));

--- a/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Tue Mar 29 16:41:18 2011 +0100
+++ b/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Wed Mar 30 18:18:11 2011 -0700
@@ -611,12 +611,18 @@
 
 # Errors related to annotation processing
 
+# 0: symbol, 1: string, 2: stack-trace
 compiler.err.proc.cant.access=\
     cannot access {0}\n\
     {1}\n\
     Consult the following stack trace for details.\n\
     {2}
 
+# 0: symbol, 1: string
+compiler.err.proc.cant.access.1=\
+    cannot access {0}\n\
+    {1}
+
 # 0: string
 compiler.err.proc.cant.find.class=\
     Could not find class file for ''{0}''.
@@ -1424,8 +1430,13 @@
 compiler.misc.bad.class.signature=\
     bad class signature: {0}
 
+#0: symbol, 1: symbol
+compiler.misc.bad.enclosing.class=\
+    bad enclosing class for {0}: {1}
+
+# 0: symbol
 compiler.misc.bad.enclosing.method=\
-    bad enclosing method attribute: {0}
+    bad enclosing method attribute for class {0}
 
 compiler.misc.bad.runtime.invisible.param.annotations=\
     bad RuntimeInvisibleParameterAnnotations attribute: {0}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/classreader/T7031108.java	Wed Mar 30 18:18:11 2011 -0700
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 7031108
+ * @summary NPE in javac.jvm.ClassReader.findMethod in PackageElement.enclosedElements from AP in incr build
+ * @library ../lib
+ * @build JavacTestingAbstractProcessor T7031108
+ * @run main T7031108
+ */
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import javax.annotation.processing.*;
+import javax.lang.model.element.*;
+import javax.tools.*;
+import javax.tools.JavaCompiler.CompilationTask;
+
+public class T7031108 extends JavacTestingAbstractProcessor {
+    public static void main(String... args) throws Exception {
+        new T7031108().run();
+    }
+
+    /* Class containing a local class definition;
+     * compiled class file will have an EnclosedMethod attribute.
+     */
+    static final JavaSource pC =
+            new JavaSource("p/C.java",
+                  "package p;\n"
+                + "class C {\n"
+                + "    void m() {\n"
+                + "        new Runnable() {\n"
+                + "            public void run() {\n"
+                + "                new Runnable() {\n"
+                + "                    public void run() { }\n"
+                + "                };\n"
+                + "            }\n"
+                + "        };\n"
+                + "    }\n"
+                + "}");
+
+    /* Dummy source file to compile while running anno processor. */
+    static final JavaSource dummy =
+            new JavaSource("Dummy.java",
+                "class Dummy { }");
+
+    void run() throws Exception {
+        JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
+        StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
+
+        // step 1: compile test classes
+        File cwd = new File(".");
+        fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(cwd));
+        compile(comp, fm, null, null, pC);
+
+        // step 2: verify functioning of processor
+        fm.setLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH,
+                fm.getLocation(StandardLocation.CLASS_PATH));
+        fm.setLocation(StandardLocation.CLASS_PATH, Arrays.asList(cwd));
+        compile(comp, fm, null, getClass().getName(), dummy);
+
+        File pC_class = new File(new File("p"), "C.class");
+        pC_class.delete();
+
+        DiagnosticCollector<JavaFileObject> dc = new DiagnosticCollector<JavaFileObject>();
+        compile(comp, fm, dc, getClass().getName(), dummy);
+        List<Diagnostic<? extends JavaFileObject>> diags =dc.getDiagnostics();
+
+        System.err.println(diags);
+        switch (diags.size()) {
+            case 0:
+                throw new Exception("no diagnostics received");
+            case 1:
+                String code = diags.get(0).getCode();
+                String expect = "compiler.err.proc.cant.access.1";
+                if (!expect.equals(code))
+                    throw new Exception("unexpected diag code: " + code
+                            + ", expected: " + expect);
+                break;
+            default:
+                throw new Exception("unexpected diags received");
+        }
+    }
+
+    void compile(JavaCompiler comp, JavaFileManager fm,
+            DiagnosticListener<JavaFileObject> dl,
+            String processor, JavaFileObject... files) throws Exception {
+        System.err.println("compile processor:" + processor + ", files:" + Arrays.asList(files));
+        List<String> opts = new ArrayList<String>();
+        if (processor != null) {
+            // opts.add("-verbose");
+            opts.addAll(Arrays.asList("-processor", processor));
+        }
+        CompilationTask task = comp.getTask(null, fm, dl, opts, null, Arrays.asList(files));
+        boolean ok = task.call();
+        if (dl == null && !ok)
+            throw new Exception("compilation failed");
+    }
+
+    static class JavaSource extends SimpleJavaFileObject {
+        JavaSource(String name, String text) {
+            super(URI.create("js://" + name), JavaFileObject.Kind.SOURCE);
+            this.text = text;
+        }
+        @Override
+        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+            return text;
+        }
+        final String text;
+    }
+
+    // annotation processor method
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        if (!roundEnv.processingOver()) {
+            PackageElement p = elements.getPackageElement("p");
+            List<? extends Element> elems = p.getEnclosedElements();
+            System.err.println("contents of package p: " + elems);
+            if (elems.size() != 1 || !elems.get(0).getSimpleName().contentEquals("C")) {
+                messager.printMessage(Diagnostic.Kind.ERROR, "unexpected package contents");
+            }
+        }
+        return true;
+    }
+}
+

--- a/langtools/test/tools/javac/diags/examples.not-yet.txt	Tue Mar 29 16:41:18 2011 +0100
+++ b/langtools/test/tools/javac/diags/examples.not-yet.txt	Wed Mar 30 18:18:11 2011 -0700
@@ -27,6 +27,7 @@
 compiler.err.prob.found.req.1                           # Check: DEAD, in unused method
 compiler.err.proc.bad.config.file                       # JavacProcessingEnvironment
 compiler.err.proc.cant.access                           # completion failure
+compiler.err.proc.cant.access.1                         # completion failure, no stack trace
 compiler.err.proc.cant.create.loader                    # security exception from service loader
 compiler.err.proc.no.service                            # JavacProcessingEnvironment: no service loader available
 compiler.err.proc.processor.bad.option.name             # cannot happen? masked by javac.err.invalid.A.key
@@ -49,6 +50,7 @@
 compiler.misc.bad.class.signature                       # bad class file
 compiler.misc.bad.const.pool.tag                        # bad class file
 compiler.misc.bad.const.pool.tag.at                     # bad class file
+compiler.misc.bad.enclosing.class                       # bad class file
 compiler.misc.bad.enclosing.method                      # bad class file
 compiler.misc.bad.runtime.invisible.param.annotations   # bad class file
 compiler.misc.bad.signature                             # bad class file