Generate names for anonymous Java classes using enclosing classes and members.

editor/util/plugins/com.google.dart.java2dart/src/com/google/dart/java2dart/Context.java

 /*
  * Copyright (c) 2012, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
  * 
  * 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
@@ skipping 50 matching lines @@
 import static com.google.dart.java2dart.util.ASTFactory.expressionStatement;
 import static com.google.dart.java2dart.util.ASTFactory.formalParameterList;
 import static com.google.dart.java2dart.util.ASTFactory.identifier;
 import static com.google.dart.java2dart.util.ASTFactory.propertyAccess;
 import static com.google.dart.java2dart.util.ASTFactory.thisExpression;
 import static com.google.dart.java2dart.util.TokenFactory.token;
 
 import org.apache.commons.io.Charsets;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTParser;
 import org.eclipse.jdt.core.dom.FileASTRequestor;
 import org.eclipse.jdt.core.dom.IBinding;
 import org.eclipse.jdt.core.dom.IMethodBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
 
@@ skipping 507 matching lines @@
         }
       }
     }
     // run processors
     {
       replaceInnerClassReferences(dartUniverse);
       unwrapVarArgIfAlreadyArray(dartUniverse);
       ensureFieldInitializers(dartUniverse);
       dontUseThisInFieldInitializers(dartUniverse);
       ensureUniqueClassMemberNames(dartUniverse);
+      renameAnonymousClassDeclarations();
       applyLocalVariableSemanticChanges(dartUniverse);
       new ConstructorSemanticProcessor(this).process(dartUniverse);
       renameConstructors(dartUniverse);
       insertEnclosingTypeForInstanceCreationArguments(dartUniverse);
     }
     // done
     return dartUniverse;
   }
 
   /**
@@ skipping 236 matching lines @@
           units.put(astFile, dartUnit);
         } catch (Throwable e) {
           throw new Error(e);
         }
       }
     },
         null);
     return units;
   }
 
+  /**
+   * Improves names for anonymous {@link ClassDeclaration}s.
+   */
+  private void renameAnonymousClassDeclarations() {
+    // prepare unused top-level names
+    Set<String> usedTopNames = Sets.newHashSet();
+    for (CompilationUnitMember unitMember : dartUniverse.getDeclarations()) {
+      if (unitMember instanceof ClassDeclaration) {
+        ClassDeclaration classDeclaration = (ClassDeclaration) unitMember;
+        String name = classDeclaration.getName().getName();
+        usedTopNames.add(name);
+      }
+    }
+    // rename anonymous types
+    for (Entry<InstanceCreationExpression, ClassDeclaration> entry : anonymousDeclarations.entrySet()) {
+      // prepare enclosing information
+      InstanceCreationExpression creation = entry.getKey();
+      ClassDeclaration enclosingClass = creation.getAncestor(ClassDeclaration.class);
+      //
+      SimpleIdentifier enclosingClassMemberName = null;
+      if (enclosingClassMemberName == null) {
+        MethodDeclaration enclosingMethod = creation.getAncestor(MethodDeclaration.class);
+        if (enclosingMethod != null) {
+          enclosingClassMemberName = enclosingMethod.getName();
+        }
+      }
+      if (enclosingClassMemberName == null) {
+        VariableDeclaration enclosingField = creation.getAncestor(VariableDeclaration.class);
+        if (enclosingField != null) {
+          enclosingClassMemberName = enclosingField.getName();
+        }
+      }
+      // prepare new name for anonymous class
+      ClassDeclaration classDeclaration = entry.getValue();
+      SimpleIdentifier nameNode = classDeclaration.getName();
+      String name = nameNode.getName();
+      name = StringUtils.substringBeforeLast(name, "_");
+      {
+        String enclosingClassName = enclosingClass.getName().getName();
+        if (!enclosingClassName.equals(name)) {
+          name = name + "_" + enclosingClassName;
+        }
+      }
+      if (enclosingClassMemberName != null) {
+        name += "_" + enclosingClassMemberName.getName();
+      }
+      // ensure unique name
+      if (!usedTopNames.add(name)) {
+        int index = 2;
+        while (true) {
+          String newName = name + "_" + index++;
+          if (usedTopNames.add(newName)) {
+            name = newName;
+            break;
+          }
+        }
+      }
+      // rename
+      renameIdentifier(nameNode, name);
+    }
+  }
+
   private void renameConstructors(CompilationUnit unit) {
     unit.accept(new RecursiveASTVisitor<Void>() {
       private final Set<String> memberNamesInClass = Sets.newHashSet();
       private int numConstructors;
 
       @Override
       public Void visitClassDeclaration(ClassDeclaration node) {
         memberNamesInClass.clear();
         numConstructors = 0;
         NodeList<ClassMember> members = node.getMembers();
@@ skipping 119 matching lines @@
                   }
                 }
               }
             }
           }
         }
       }
     });
   }
 }