New analyzer_experimental snapshot.

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 29 matching lines @@
 import com.google.dart.engine.ast.SimpleIdentifier;
 import com.google.dart.engine.ast.SuperConstructorInvocation;
 import com.google.dart.engine.ast.ThisExpression;
 import com.google.dart.engine.ast.VariableDeclaration;
 import com.google.dart.engine.ast.VariableDeclarationList;
 import com.google.dart.engine.ast.visitor.GeneralizingASTVisitor;
 import com.google.dart.engine.ast.visitor.RecursiveASTVisitor;
 import com.google.dart.engine.scanner.Keyword;
 import com.google.dart.engine.scanner.KeywordToken;
 import com.google.dart.engine.scanner.TokenType;
+import com.google.dart.java2dart.util.Bindings;
 import com.google.dart.java2dart.util.JavaUtils;
 
 import static com.google.dart.java2dart.util.ASTFactory.assignmentExpression;
 import static com.google.dart.java2dart.util.ASTFactory.block;
 import static com.google.dart.java2dart.util.ASTFactory.blockFunctionBody;
 import static com.google.dart.java2dart.util.ASTFactory.compilationUnit;
 import static com.google.dart.java2dart.util.ASTFactory.constructorDeclaration;
 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;
@@ skipping 264 matching lines @@
           index++;
         }
       }
     });
   }
 
   public void ensureUniqueClassMemberNames(CompilationUnit unit) {
     unit.accept(new RecursiveASTVisitor<Void>() {
       private final Set<ClassMember> untouchableMethods = Sets.newHashSet();
       private final Map<String, ClassMember> usedClassMembers = Maps.newHashMap();
+      private final Set<String> superNames = Sets.newHashSet();
+      private final Map<String, List<IMethodBinding>> superMembers = Maps.newHashMap();
 
       @Override
       public Void visitClassDeclaration(ClassDeclaration node) {
+        untouchableMethods.clear();
         usedClassMembers.clear();
+        superNames.clear();
+        superMembers.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())) {
                   usedClassMembers.put(method.getName(), null);
+                } else {
+                  addSuperMember(method);
                 }
               }
               binding = binding.getSuperclass();
             }
           }
         }
         // fill "untouchable" methods
         for (ClassMember member : node.getMembers()) {
           if (member instanceof MethodDeclaration) {
             MethodDeclaration methodDeclaration = (MethodDeclaration) member;
@@ skipping 16 matching lines @@
             {
               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;
                 }
               }
             }
+            // may be overloaded method
+            {
+              Object binding = nodeToBinding.get(method);
+              if (binding instanceof IMethodBinding) {
+                IMethodBinding methodBinding = (IMethodBinding) binding;
+                String name = methodBinding.getName();
+                if (superNames.contains(name)) {
+                  IMethodBinding over = Bindings.findOverriddenMethod(methodBinding, false);
+                  if (over == null) {
+                    usedClassMembers.put(name, null);
+                  }
+                }
+              }
+            }
             // 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(), fieldDeclaration);
             }
           }
         }
         // no recursion
         return null;
       }
 
+      private void addSuperMember(IMethodBinding binding) {
+        String name = binding.getName();
+        superNames.add(name);
+        List<IMethodBinding> members = superMembers.get(name);
+        if (members == null) {
+          members = Lists.newArrayList();
+          superMembers.put(name, members);
+        }
+        members.add(binding);
+      }
+
       private void ensureUniqueName(Identifier declarationName, ClassMember member) {
         if (declarationName instanceof SimpleIdentifier) {
           SimpleIdentifier declarationIdentifier = (SimpleIdentifier) declarationName;
           String name = declarationIdentifier.getName();
           if (!isUniqueClassMemberName(name)) {
             String newName = generateUniqueName(name);
             // rename binding
             if (!newName.equals(name)) {
               renameIdentifier(declarationIdentifier, newName);
               name = newName;
@@ skipping 582 matching lines @@
                   }
                 }
               }
             }
           }
         }
       }
     });
   }
 }