[java decompiler] excludes false inner classes

src/org/jetbrains/java/decompiler/main/ClassesProcessor.java

@@ -77,22 +77,20 @@ public class ClassesProcessor {
 
               Inner rec = new Inner();
               rec.simpleName = simpleName;
-              rec.type = entry.outerNameIdx != 0 ? ClassNode.CLASS_MEMBER : entry.simpleNameIdx != 0 ? ClassNode.CLASS_LOCAL : ClassNode.CLASS_ANONYMOUS;
+              rec.type = entry.simpleNameIdx == 0 ? ClassNode.CLASS_ANONYMOUS : entry.outerNameIdx == 0 ? ClassNode.CLASS_LOCAL : ClassNode.CLASS_MEMBER;
               rec.accessFlags = entry.accessFlags;
 
               // enclosing class
-              String enclClassName;
-              if (entry.outerNameIdx != 0) {
-                enclClassName = entry.enclosingName;
+              String enclClassName = entry.outerNameIdx != 0 ? entry.enclosingName : cl.qualifiedName;
+              if (enclClassName == null || innerName.equals(enclClassName)) {
+                continue;  // invalid name or self reference
               }
-              else {
-                enclClassName = cl.qualifiedName;
+              if (rec.type == ClassNode.CLASS_MEMBER && !innerName.equals(enclClassName + '$' + entry.simpleName)) {
+                continue;  // not a real inner class
               }
 
-              if (!innerName.equals(enclClassName)) {  // self reference
-                StructClass enclosing_class = context.getClasses().get(enclClassName);
-                if (enclosing_class != null && enclosing_class.isOwn()) { // own classes only
-
+              StructClass enclosingClass = context.getClasses().get(enclClassName);
+              if (enclosingClass != null && enclosingClass.isOwn()) { // own classes only
                 Inner existingRec = mapInnerClasses.get(innerName);
                 if (existingRec == null) {
                   mapInnerClasses.put(innerName, rec);
@@ -103,15 +101,13 @@ public class ClassesProcessor {
                 }
 
                 // reference to the nested class
-                  mapNestedClassReferences.computeIfAbsent(enclClassName, k1 -> new HashSet<>()).add(innerName);
-
+                mapNestedClassReferences.computeIfAbsent(enclClassName, k -> new HashSet<>()).add(innerName);
                 // reference to the enclosing class
                 mapEnclosingClassReferences.computeIfAbsent(innerName, k -> new HashSet<>()).add(enclClassName);
               }
             }
           }
         }
-        }
 
         ClassNode node = new ClassNode(ClassNode.CLASS_ROOT, cl);
         node.access = cl.getAccessFlags();
@@ -136,7 +132,6 @@ public class ClassesProcessor {
 
             Set<String> setNestedClasses = mapNestedClassReferences.get(superClass);
             if (setNestedClasses != null) {
-
               StructClass scl = superNode.classStruct;
               StructInnerClassesAttribute inner = (StructInnerClassesAttribute)scl.getAttribute("InnerClasses");
 

test/org/jetbrains/java/decompiler/SingleClassesTest.java

@@ -111,6 +111,8 @@ public class SingleClassesTest {
   //@Test public void testInUse() { doTest("pkg/TestInUse"); }
   //@Test public void testInterfaceSuper() { doTest("pkg/TestInterfaceSuper"); }
 
+  @Test public void testGroovyTrait() { doTest("pkg/TestGroovyTrait"); }
+
   private void doTest(String testFile, String... companionFiles) {
     ConsoleDecompiler decompiler = fixture.getDecompiler();
 

testData/results/TestGroovyTrait.dec

@@ -0,0 +1,17 @@
+package pkg;
+
+import groovy.transform.Trait;
+import org.codehaus.groovy.transform.trait.Traits.Implemented;
+
+@Trait
+public interface TestGroovyTrait {
+   @Implemented
+   Object myMethod();
+
+   @Implemented
+   Object getMyField();
+
+   @Implemented
+   void setMyField(Object var1);
+}
+

testData/src/pkg/TestGroovyTrait.groovy

@@ -0,0 +1,8 @@
+package pkg
+
+trait TestGroovyTrait {
+  def myField = 42
+  def myMethod() {
+    42
+  }
+}