Issue 13584. Fix for Java/Dart local variable scoping mismatch.

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 10 matching lines @@
 import com.google.common.io.Files;
 import com.google.dart.engine.ast.ASTNode;
 import com.google.dart.engine.ast.ArgumentList;
 import com.google.dart.engine.ast.Block;
 import com.google.dart.engine.ast.BlockFunctionBody;
 import com.google.dart.engine.ast.ClassDeclaration;
 import com.google.dart.engine.ast.ClassMember;
 import com.google.dart.engine.ast.CompilationUnit;
 import com.google.dart.engine.ast.CompilationUnitMember;
 import com.google.dart.engine.ast.ConstructorDeclaration;
-import com.google.dart.engine.ast.DeclaredIdentifier;
 import com.google.dart.engine.ast.Expression;
 import com.google.dart.engine.ast.FieldDeclaration;
-import com.google.dart.engine.ast.ForEachStatement;
-import com.google.dart.engine.ast.FormalParameter;
-import com.google.dart.engine.ast.FormalParameterList;
 import com.google.dart.engine.ast.Identifier;
 import com.google.dart.engine.ast.InstanceCreationExpression;
 import com.google.dart.engine.ast.ListLiteral;
 import com.google.dart.engine.ast.MethodDeclaration;
 import com.google.dart.engine.ast.MethodInvocation;
 import com.google.dart.engine.ast.NodeList;
-import com.google.dart.engine.ast.PropertyAccess;
 import com.google.dart.engine.ast.RedirectingConstructorInvocation;
 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.processor.ConstructorSemanticProcessor;
+import com.google.dart.java2dart.processor.LocalVariablesSemanticProcessor;
 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;
 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.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;
 
 import java.io.File;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ skipping 23 matching lines @@
   private final List<File> sourceFolders = Lists.newArrayList();
   private final List<File> sourceFiles = Lists.newArrayList();
 
   private final Map<String, String> renameMap = Maps.newHashMap();
   private final Set<String> notPropertySet = Sets.newHashSet();
 
   private final CompilationUnit dartUniverse = compilationUnit();
   private final Map<File, List<CompilationUnitMember>> fileToMembers = Maps.newHashMap();
   private final Map<CompilationUnitMember, File> memberToFile = Maps.newHashMap();
   // information about names
-  private static final Set<String> forbiddenNames = Sets.newHashSet();
+  public static final Set<String> FORBIDDEN_NAMES = Sets.newHashSet();
   private final Set<String> usedNames = Sets.newHashSet();
   private final Set<ClassMember> privateClassMembers = Sets.newHashSet();
   private final Map<SimpleIdentifier, String> identifierToName = Maps.newHashMap();
   private final Map<String, Object> signatureToBinding = Maps.newHashMap();
   private final Map<Object, List<SimpleIdentifier>> bindingToIdentifiers = Maps.newHashMap();
   private final Map<ASTNode, IBinding> nodeToBinding = Maps.newHashMap();
   private final Map<ASTNode, ITypeBinding> nodeToTypeBinding = Maps.newHashMap();
   private final Map<InstanceCreationExpression, ClassDeclaration> anonymousDeclarations = Maps.newHashMap();
   private final Set<SimpleIdentifier> innerClassNames = Sets.newHashSet();
   // information about constructors
   private int technicalConstructorIndex;
   private final Map<IMethodBinding, ConstructorDescription> bindingToConstructor = Maps.newHashMap();
   private final Map<ConstructorDeclaration, IMethodBinding> constructorToBinding = Maps.newHashMap();
   // information about inner classes
   private int technicalInnerClassIndex;
   private int technicalAnonymousClassIndex;
 
   static {
     for (Keyword keyword : Keyword.values()) {
       if (!keyword.isPseudoKeyword()) {
-        forbiddenNames.add(keyword.getSyntax());
+        FORBIDDEN_NAMES.add(keyword.getSyntax());
       }
     }
   }
 
   /**
    * Specifies that given {@link File} should be added to Java classpath.
    */
   public void addClasspathFile(File file) {
     Assert.isLegal(file.exists(), "File '" + file + "' does not exist.");
     Assert.isLegal(file.isFile(), "File '" + file + "' is not a regular file.");
@@ skipping 39 matching lines @@
   /**
    * Specifies that given folder is a source folder (root of Java packages hierarchy).
    */
   public void addSourceFolder(File folder) {
     Assert.isLegal(folder.exists(), "Folder '" + folder + "' does not exist.");
     Assert.isLegal(folder.isDirectory(), "Folder '" + folder + "' is not a folder.");
     folder = folder.getAbsoluteFile();
     sourceFolders.add(folder);
   }
 
+  public void applyLocalVariableSemanticChanges(CompilationUnit unit) {
+    new LocalVariablesSemanticProcessor(this).process(unit);
+  }
+
   /**
    * @return {@code true} if the method with the given signature (which could be made getter or
    *         setter) is allowed to be converted into getter/setter.
    */
   public boolean canMakeProperty(SimpleIdentifier identifier) {
     IBinding binding = getNodeBinding(identifier);
     String signature = JavaUtils.getJdtSignature(binding);
     return !notPropertySet.contains(signature);
   }
 
   /**
    * In Java we can have method parameter "foo" and invoke method named "foo", and parameter will
    * not shadow invoked method. But in Dart it will.
    */
   public void ensureMethodParameterDoesNotHide(CompilationUnit unit) {

[Brian Wilkerson, 2013/10/01 00:34:55]

Do we need to keep this method?

[scheglov, 2013/10/01 01:18:51]

Done.

-    unit.accept(new RecursiveASTVisitor<Void>() {
-      @Override
-      public Void visitMethodDeclaration(MethodDeclaration node) {
-        FormalParameterList parameterList = node.getParameters();
-        if (parameterList != null) {
-          for (FormalParameter parameter : parameterList.getParameters()) {
-            final String parameterName = parameter.getIdentifier().getName();
-            final Object parameterBinding = getNodeBinding(parameter.getIdentifier());
-            final AtomicBoolean hasHiding = new AtomicBoolean();
-            node.accept(new RecursiveASTVisitor<Void>() {
-              @Override
-              public Void visitSimpleIdentifier(SimpleIdentifier node) {
-                if (node.getName().equals(parameterName)
-                    && getNodeBinding(node) != parameterBinding) {
-                  hasHiding.set(true);
-                }
-                return super.visitSimpleIdentifier(node);
-              }
-            });
-            if (hasHiding.get()) {
-              Set<String> used = getSuperMembersNames(node);
-              String newName = generateUniqueParameterName(used, parameterName);
-              renameIdentifier(parameter.getIdentifier(), newName);
-            }
-          }
-        }
-        return super.visitMethodDeclaration(node);
-      }
-
-      private String generateUniqueParameterName(Set<String> used, String name) {
-        int index = 2;
-        while (true) {
-          String newName = name + index;
-          if (!used.contains(newName)) {
-            return newName;
-          }
-          index++;
-        }
-      }
-    });
-  }
-
-  public void ensureNoVariableNameReferenceFromInitializer(CompilationUnit unit) {
-    unit.accept(new RecursiveASTVisitor<Void>() {
-      private Set<String> hierarchyNames;
-      private Set<String> methodNames;
-      private String currentVariableName = null;
-      private boolean hasNameReference = false;
-
-      @Override
-      public Void visitClassDeclaration(ClassDeclaration node) {
-        hierarchyNames = null;
-        try {
-          return super.visitClassDeclaration(node);
-        } finally {
-          hierarchyNames = null;
-        }
-      }
-
-      @Override
-      public Void visitForEachStatement(ForEachStatement node) {
-        DeclaredIdentifier loopVariable = node.getLoopVariable();
-        if (loopVariable != null) {
-          SimpleIdentifier nameNode = loopVariable.getIdentifier();
-          String variableName = nameNode.getName();
-          if (forbiddenNames.contains(variableName)) {
-            ensureHierarchyNames(node);
-            ensureMethodNames(node);
-            String newName = generateUniqueVariableName(variableName);
-            renameIdentifier(nameNode, newName);
-          }
-        }
-        return super.visitForEachStatement(node);
-      }
-
-      @Override
-      public Void visitMethodDeclaration(MethodDeclaration node) {
-        methodNames = null;
-        try {
-          return super.visitMethodDeclaration(node);
-        } finally {
-          methodNames = null;
-        }
-      }
-
-      @Override
-      public Void visitSimpleIdentifier(SimpleIdentifier node) {
-        if (node.getName().equals(currentVariableName)) {
-          ASTNode parent = node.getParent();
-          // name()
-          if (parent instanceof MethodInvocation) {
-            MethodInvocation invocation = (MethodInvocation) parent;
-            if (invocation.getMethodName() == node) {
-              // name = target.name()
-              if (invocation.getTarget() != null) {
-                return null;
-              }
-              // name = name()
-              hasNameReference = true;
-              return null;
-            }
-          }
-          // name = target.name
-          if (parent instanceof PropertyAccess) {
-            PropertyAccess propertyAccess = (PropertyAccess) parent;
-            if (propertyAccess.getPropertyName() == node && propertyAccess.getTarget() != null) {
-              return null;
-            }
-          }
-          // name = name_whichWasGetMethod_butNowGetter
-          {
-            Object bindingObject = getNodeBinding(node);
-            if (bindingObject instanceof IMethodBinding) {
-              SyntaxTranslator.replaceNode(parent, node, propertyAccess(thisExpression(), node));
-              return null;
-            }
-          }
-          // OK, this is really conflict
-          hasNameReference = true;
-        }
-        return null;
-      }
-
-      @Override
-      public Void visitVariableDeclaration(VariableDeclaration node) {
-        String oldVariableName = currentVariableName;
-        try {
-          currentVariableName = node.getName().getName();
-          hasNameReference = false;
-          Expression initializer = node.getInitializer();
-          if (initializer != null) {
-            initializer.accept(this);
-          }
-          if (hasNameReference || forbiddenNames.contains(currentVariableName)) {
-            ensureHierarchyNames(node);
-            ensureMethodNames(node);
-            String newName = generateUniqueVariableName(currentVariableName);
-            renameIdentifier(node.getName(), newName);
-          }
-        } finally {
-          currentVariableName = oldVariableName;
-        }
-        return null;
-      }
-
-      private void ensureHierarchyNames(ASTNode node) {
-        if (hierarchyNames != null) {
-          return;
-        }
-        hierarchyNames = getSuperMembersNames(node);
-      }
-
-      private void ensureMethodNames(ASTNode node) {
-        methodNames = Sets.newHashSet();
-        MethodDeclaration method = node.getAncestor(MethodDeclaration.class);
-        if (method != null) {
-          method.accept(new RecursiveASTVisitor<Void>() {
-            @Override
-            public Void visitVariableDeclaration(VariableDeclaration node) {
-              methodNames.add(node.getName().getName());
-              return super.visitVariableDeclaration(node);
-            }
-          });
-        }
-      }
-
-      /**
-       * @return the new name for variable which does not conflict with name of any member in super
-       *         classes - {@link #hierarchyNames}.
-       */
-      private String generateUniqueVariableName(String name) {
-        int index = 2;
-        while (true) {
-          String newName = name + index;
-          if (!hierarchyNames.contains(newName) && !methodNames.contains(newName)
-              && !forbiddenNames.contains(newName)) {
-            methodNames.add(newName);
-            return newName;
-          }
-          index++;
-        }
-      }
-    });
+//    unit.accept(new RecursiveASTVisitor<Void>() {
+//      @Override
+//      public Void visitMethodDeclaration(MethodDeclaration node) {
+//        FormalParameterList parameterList = node.getParameters();
+//        if (parameterList != null) {
+//          for (FormalParameter parameter : parameterList.getParameters()) {
+//            final String parameterName = parameter.getIdentifier().getName();
+//            final Object parameterBinding = getNodeBinding(parameter.getIdentifier());
+//            final AtomicBoolean hasHiding = new AtomicBoolean();
+//            node.accept(new RecursiveASTVisitor<Void>() {
+//              @Override
+//              public Void visitSimpleIdentifier(SimpleIdentifier node) {
+//                if (node.getName().equals(parameterName)
+//                    && getNodeBinding(node) != parameterBinding) {
+//                  hasHiding.set(true);
+//                }
+//                return super.visitSimpleIdentifier(node);
+//              }
+//            });
+//            if (hasHiding.get()) {
+//              Set<String> used = getSuperMembersNames(node);
+//              String newName = generateUniqueParameterName(used, parameterName);
+//              renameIdentifier(parameter.getIdentifier(), newName);
+//            }
+//          }
+//        }
+//        return super.visitMethodDeclaration(node);
+//      }
+//
+//      private String generateUniqueParameterName(Set<String> used, String name) {
+//        int index = 2;
+//        while (true) {
+//          String newName = name + index;
+//          if (!used.contains(newName)) {
+//            return newName;
+//          }
+//          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
@@ skipping 121 matching lines @@
           }
         }
         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 !FORBIDDEN_NAMES.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 62 matching lines @@
   /**
    * @return all references (actual references and declarations)
    */
   public List<SimpleIdentifier> getReferences(SimpleIdentifier target) {
     Object binding = nodeToBinding.get(target);
     List<SimpleIdentifier> references = bindingToIdentifiers.get(binding);
     return references != null ? references : Lists.<SimpleIdentifier> newArrayList();
   }
 
   /**
+   * @return the name of member declared in enclosing {@link ClassDeclaration} and its super
+   *         classes.
+   */
+  public Set<String> getSuperMembersNames(ASTNode node) {
+    Set<String> hierarchyNames = Sets.newHashSet();
+    ClassDeclaration classDeclaration = node.getAncestor(ClassDeclaration.class);
+    org.eclipse.jdt.core.dom.ITypeBinding binding = getNodeTypeBinding(classDeclaration);
+    if (binding != null) {
+      binding = binding.getSuperclass();
+      while (binding != null) {
+        for (org.eclipse.jdt.core.dom.IVariableBinding field : binding.getDeclaredFields()) {
+          hierarchyNames.add(field.getName());
+        }
+        for (org.eclipse.jdt.core.dom.IMethodBinding method : binding.getDeclaredMethods()) {
+          hierarchyNames.add(method.getName());
+        }
+        binding = binding.getSuperclass();
+      }
+    }
+    return hierarchyNames;
+  }
+
+  public boolean isFieldBinding(ASTNode node) {
+    IBinding binding = getNodeBinding(node);
+    if (binding instanceof IVariableBinding) {
+      return ((IVariableBinding) binding).isField();
+    }
+    return false;
+  }
+
+  public boolean isMethodBinding(ASTNode node) {
+    IBinding binding = getNodeBinding(node);
+    return binding instanceof IMethodBinding;
+  }
+
+  /**
    * Remembers that "identifier" is reference to the given Java binding.
    */
   public void putReference(SimpleIdentifier identifier, IBinding binding, String bindingSignature) {
     if (binding != null) {
       signatureToBinding.put(bindingSignature, binding);
       identifierToName.put(identifier, identifier.getName());
       // remember binding for reference
       nodeToBinding.put(identifier, binding);
       // add reference to binding
       List<SimpleIdentifier> identifiers = bindingToIdentifiers.get(binding);
@@ skipping 75 matching lines @@
         }
       }
     }
     // run processors
     {
       replaceInnerClassReferences(dartUniverse);
       unwrapVarArgIfAlreadyArray(dartUniverse);
       ensureFieldInitializers(dartUniverse);
       dontUseThisInFieldInitializers(dartUniverse);
       ensureUniqueClassMemberNames(dartUniverse);
-      ensureNoVariableNameReferenceFromInitializer(dartUniverse);
+      applyLocalVariableSemanticChanges(dartUniverse);
       ensureMethodParameterDoesNotHide(dartUniverse);
       new ConstructorSemanticProcessor(this).process(dartUniverse);
       renameConstructors(dartUniverse);
       insertEnclosingTypeForInstanceCreationArguments(dartUniverse);
     }
     // done
     return dartUniverse;
   }
 
   /**
@@ skipping 160 matching lines @@
             if (initializer != null) {
               variable.setInitializer(initializer);
             }
           }
         }
         return super.visitFieldDeclaration(node);
       }
     });
   }
 
-  /**
-   * @return the name of member declared in enclosing {@link ClassDeclaration} and its super
-   *         classes.
-   */
-  private Set<String> getSuperMembersNames(ASTNode node) {
-    Set<String> hierarchyNames = Sets.newHashSet();
-    ClassDeclaration classDeclaration = node.getAncestor(ClassDeclaration.class);
-    org.eclipse.jdt.core.dom.ITypeBinding binding = getNodeTypeBinding(classDeclaration);
-    if (binding != null) {
-      binding = binding.getSuperclass();
-      while (binding != null) {
-        for (org.eclipse.jdt.core.dom.IVariableBinding field : binding.getDeclaredFields()) {
-          hierarchyNames.add(field.getName());
-        }
-        for (org.eclipse.jdt.core.dom.IMethodBinding method : binding.getDeclaredMethods()) {
-          hierarchyNames.add(method.getName());
-        }
-        binding = binding.getSuperclass();
-      }
-    }
-    return hierarchyNames;
-  }
-
   private void insertEnclosingTypeForInstanceCreationArguments(CompilationUnit unit) {
     unit.accept(new RecursiveASTVisitor<Void>() {
       @Override
       public Void visitInstanceCreationExpression(InstanceCreationExpression node) {
         IMethodBinding binding = (IMethodBinding) getNodeBinding(node);
         ConstructorDescription constructorDescription = getConstructorDescription(binding);
         if (constructorDescription.insertEnclosingTypeRef) {
           node.getArgumentList().getArguments().add(0, thisExpression());
         }
         return super.visitInstanceCreationExpression(node);
@@ skipping 183 matching lines @@
                   }
                 }
               }
             }
           }
         }
       }
     });
   }
 }