Fix build after analyzer_experimental changes

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 53 matching lines @@
 import static com.google.dart.java2dart.util.ASTFactory.thisExpression;
 import static com.google.dart.java2dart.util.TokenFactory.token;
 
 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 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;
@@ skipping 18 matching lines @@
       this.binding = binding;
     }
   }
 
   private static final String[] JAVA_EXTENSION = {"java"};
   private final List<File> classpathFiles = Lists.newArrayList();
   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();
   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, Object> nodeToBinding = 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;
@@ skipping 10 matching lines @@
    * 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.");
     file = file.getAbsoluteFile();
     classpathFiles.add(file);
   }
 
   /**
-   * Specifies that field with given signature should be renamed before normalizing member names.
+   * Specifies that the method with given signature should not be converted to getter/setter.
+   */
+  public void addNotProperty(String signature) {
+    notPropertySet.add(signature);
+  }
+
+  /**
+   * Specifies that method with given signature should be renamed before normalizing member names.
    */
   public void addRename(String signature, String newName) {
     renameMap.put(signature, newName);
   }
 
   /**
    * Specifies that given {@link File} should be translated.
    */
   public void addSourceFile(File file) {
     Assert.isLegal(file.exists(), "File '" + file + "' does not exist.");
@@ skipping 17 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);
   }
 
   /**
+   * @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) {
     unit.accept(new RecursiveASTVisitor<Void>() {
       @Override
       public Void visitMethodDeclaration(MethodDeclaration node) {
         FormalParameterList parameterList = node.getParameters();
         if (parameterList != null) {
           for (FormalParameter parameter : parameterList.getParameters()) {
@@ skipping 340 matching lines @@
     return name;
   }
 
   public Map<CompilationUnitMember, File> getMemberToFile() {
     return memberToFile;
   }
 
   /**
    * @return some Java binding for the given Dart {@link ASTNode}.
    */
-  public Object getNodeBinding(ASTNode node) {
+  public IBinding getNodeBinding(ASTNode node) {
     return nodeToBinding.get(node);
   }
 
   /**
    * @return some Java {@link ITypeBinding} for the given Dart {@link ASTNode}.
    */
   public ITypeBinding getNodeTypeBinding(ASTNode node) {
     return nodeToTypeBinding.get(node);
   }
 
@@ skipping 151 matching lines @@
    * Remembers that given {@link SimpleIdentifier} is the name of inner class and all references to
    * it should be renamed.
    */
   void putInnerClassName(SimpleIdentifier identifier) {
     innerClassNames.add(identifier);
   }
 
   /**
    * Remembers some Java binding for the given Dart {@link ASTNode}.
    */
-  void putNodeBinding(ASTNode node, Object binding) {
+  void putNodeBinding(ASTNode node, IBinding binding) {
     nodeToBinding.put(node, binding);
   }
 
   /**
    * Remembers Java {@link ITypeBinding} for the given Dart {@link ASTNode}.
    */
   void putNodeTypeBinding(ASTNode node, ITypeBinding binding) {
     nodeToTypeBinding.put(node, binding);
   }
 
   /**
    * Remembers that given {@link ClassMember} was created for private Java element.
    */
   void putPrivateClassMember(ClassMember member) {
     privateClassMembers.add(member);
   }
 
   /**
    * Remembers that "identifier" is reference to the given Java binding.
    */
-  void putReference(SimpleIdentifier identifier, Object binding, String bindingSignature) {
+  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);
       if (identifiers == null) {
         identifiers = Lists.newLinkedList();
         bindingToIdentifiers.put(binding, identifiers);
@@ skipping 316 matching lines @@
                   }
                 }
               }
             }
           }
         }
       }
     });
   }
 }