Getter and setter methods can share name.

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 233 matching lines @@
           currentVariableName = oldVariableName;
         }
         return null;
       }
     });
   }
 
   public void ensureUniqueClassMemberNames(CompilationUnit unit) {
     unit.accept(new RecursiveASTVisitor<Void>() {
       private final Set<ClassMember> untouchableMethods = Sets.newHashSet();
-      private final Set<String> usedClassMemberNames = Sets.newHashSet();
+      private final Map<String, ClassMember> usedClassMembers = Maps.newHashMap();
 
       @Override
       public Void visitClassDeclaration(ClassDeclaration node) {
-        usedClassMemberNames.clear();
+        usedClassMembers.clear();
         // fill "static" methods from super classes
         {
           org.eclipse.jdt.core.dom.ITypeBinding binding = getNodeTypeBinding(node);
           if (binding != null) {
             binding = binding.getSuperclass();
             while (binding != null) {
               for (org.eclipse.jdt.core.dom.IMethodBinding method : binding.getDeclaredMethods()) {
                 if (org.eclipse.jdt.core.dom.Modifier.isStatic(method.getModifiers())) {
-                  usedClassMemberNames.add(method.getName());
+                  usedClassMembers.put(method.getName(), null);
                 }
               }
               binding = binding.getSuperclass();
             }
           }
         }
         // fill "untouchable" methods
         for (ClassMember member : node.getMembers()) {
           if (member instanceof MethodDeclaration) {
             MethodDeclaration methodDeclaration = (MethodDeclaration) member;
             Object binding = nodeToBinding.get(member);
             if (JavaUtils.isMethodDeclaredInClass(binding, "java.lang.Object")) {
               untouchableMethods.add(member);
-              usedClassMemberNames.add(methodDeclaration.getName().getName());
+              usedClassMembers.put(methodDeclaration.getName().getName(), null);
             }
           }
         }
         // ensure unique method names (and prefer to keep method name over field name)
         for (ClassMember member : node.getMembers()) {
           if (member instanceof MethodDeclaration) {
-            MethodDeclaration methodDeclaration = (MethodDeclaration) member;
-            if (untouchableMethods.contains(methodDeclaration)) {
+            MethodDeclaration method = (MethodDeclaration) member;
+            // untouchable
+            if (untouchableMethods.contains(method)) {
               continue;
             }
-            ensureUniqueName(methodDeclaration.getName());
+            // getter/setter can share name
+            {
+              ClassMember otherMember = usedClassMembers.get(method.getName().getName());
+              if (otherMember instanceof MethodDeclaration) {
+                MethodDeclaration otherMethod = (MethodDeclaration) otherMember;
+                if (method.isGetter() && otherMethod.isSetter() || method.isSetter()
+                    && otherMethod.isGetter()) {
+                  continue;
+                }
+              }
+            }
+            // ensure unique name
+            ensureUniqueName(method.getName(), method);
           }
         }
         // ensure unique field names (if name is already used be method)
         for (ClassMember member : node.getMembers()) {
           if (member instanceof FieldDeclaration) {
             FieldDeclaration fieldDeclaration = (FieldDeclaration) member;
             for (VariableDeclaration field : fieldDeclaration.getFields().getVariables()) {
-              ensureUniqueName(field.getName());
+              ensureUniqueName(field.getName(), fieldDeclaration);
             }
           }
         }
         // no recursion
         return null;
       }
 
-      private void ensureUniqueName(Identifier declarationName) {
+      private void ensureUniqueName(Identifier declarationName, ClassMember member) {
         if (declarationName instanceof SimpleIdentifier) {
           SimpleIdentifier declarationIdentifier = (SimpleIdentifier) declarationName;
           String name = declarationIdentifier.getName();
-          if (forbiddenNames.contains(name) || usedClassMemberNames.contains(name)) {
+          if (!isUniqueClassMemberName(name)) {
             String newName = generateUniqueName(name);
             // rename binding
             if (!newName.equals(name)) {
               renameIdentifier(declarationIdentifier, newName);
               name = newName;
             }
           }
           // remember that name is used
-          usedClassMemberNames.add(name);
+          usedClassMembers.put(name, member);
         }
       }
+
+      private String generateUniqueName(String name) {
+        if (!isGloballyUniqueClassMemberName(name)) {
+          int index = 2;
+          while (true) {
+            String newName = name + index;
+            if (isGloballyUniqueClassMemberName(newName)) {
+              usedNames.add(newName);
+              return newName;
+            }
+            index++;
+          }
+        }
+        return name;
+      }
+
+      private boolean isGloballyUniqueClassMemberName(String name) {
+        return isUniqueClassMemberName(name) && !usedNames.contains(name);
+      }
+
+      private boolean isUniqueClassMemberName(String name) {
+        return !forbiddenNames.contains(name) && !usedClassMembers.containsKey(name);
+      }
     });
   }
 
   /**
    * @return the artificial {@link ClassDeclaration}created for Java creation of anonymous class
    *         declaration.
    */
   public ClassDeclaration getAnonymousDeclaration(InstanceCreationExpression creation) {
     return anonymousDeclarations.get(creation);
   }
@@ skipping 531 matching lines @@
                 }
               }
             }
           }
         }
         return super.visitMethodInvocation(node);
       }
     });
   }
 }