Support for @DartName and @DartOptional annotations.

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 214 matching lines @@
       node.accept(new UnifyingAstVisitor<Void>() {
         @Override
         public Void visitNode(AstNode node) {
           clearNode(node);
           return super.visitNode(node);
         }
       });
     }
   }
 
-  public void ensureUniqueClassMemberNames(CompilationUnit unit) {
-    unit.accept(new RecursiveAstVisitor<Void>() {
+  public void ensureUniqueClassMemberNames() {
+    dartUniverse.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();
@@ skipping 131 matching lines @@
 
   /**
    * @return the artificial {@link ClassDeclaration}created for Java creation of anonymous class
    *         declaration.
    */
   public ClassDeclaration getAnonymousDeclaration(InstanceCreationExpression creation) {
     return anonymousDeclarations.get(creation);
   }
 
   /**
+   * @return some Java binding for the given Dart {@link ConstructorDeclaration}.
+   */
+  public IMethodBinding getConstructorBinding(ConstructorDeclaration node) {
+    return constructorToBinding.get(node);
+  }
+
+  /**
    * @return the not <code>null</code> {@link ConstructorDescription}, may be just added.
    */
   public ConstructorDescription getConstructorDescription(ConstructorDeclaration node) {
-    IMethodBinding binding = constructorToBinding.get(node);
+    IMethodBinding binding = getConstructorBinding(node);
     return getConstructorDescription(binding);
   }
 
   /**
    * @return the not <code>null</code> {@link ConstructorDescription}, may be just added.
    */
   public ConstructorDescription getConstructorDescription(IMethodBinding binding) {
     binding = (IMethodBinding) Bindings.getDeclaration(binding);
     ConstructorDescription description = bindingToConstructor.get(binding);
     if (description == null) {
@@ skipping 11 matching lines @@
    * We rename {@link SimpleIdentifier}s, but sometimes we need to know original name.
    */
   public String getIdentifierOriginalName(SimpleIdentifier identifier) {
     String name = identifierToName.get(identifier);
     if (name == null) {
       name = identifier.getName();
     }
     return name;
   }
 
+  public List<MethodInvocation> getInvocations(MethodDeclaration method) {
+    List<MethodInvocation> invocations = Lists.newArrayList();
+    SimpleIdentifier methodName = method.getName();
+    List<SimpleIdentifier> references = getReferences(methodName);
+    for (SimpleIdentifier reference : references) {
+      if (reference.getParent() instanceof MethodInvocation) {
+        MethodInvocation invocation = (MethodInvocation) reference.getParent();
+        if (invocation.getMethodName() == reference) {
+          invocations.add(invocation);
+        }
+      }
+    }
+    return invocations;
+  }
+
   public Map<CompilationUnitMember, File> getMemberToFile() {
     return memberToFile;
   }
 
   /**
    * Returns all node annotations. Used for testing.
    */
   public Map<AstNode, List<ParsedAnnotation>> getNodeAnnotations() {
     return nodeAnnotations;
   }
@@ skipping 98 matching lines @@
    */
   public void removeReference(SimpleIdentifier identifier) {
     IBinding binding = getNodeBinding(identifier);
     List<SimpleIdentifier> identifiers = bindingToIdentifiers.get(binding);
     if (identifiers != null) {
       identifiers.remove(identifier);
     }
   }
 
   public void renameConstructor(ConstructorDeclaration node, String name) {
-    IMethodBinding binding = constructorToBinding.get(node);
+    IMethodBinding binding = getConstructorBinding(node);
     //
     SimpleIdentifier newIdentifier;
     if (name == null) {
       newIdentifier = null;
     } else {
       newIdentifier = identifier(name);
     }
     // rename constructor
     node.setName(newIdentifier);
     // update references
@@ skipping 54 matching lines @@
       }
     }
     // run processors
     {
       replaceInnerClassReferences(dartUniverse);
       unwrapVarArgIfAlreadyArray(dartUniverse);
       ensureFieldInitializers(dartUniverse);
       dontUseThisInFieldInitializers(dartUniverse);
       renameAnonymousClassDeclarations();
       renamePrivateClassMembers();
-      ensureUniqueClassMemberNames(dartUniverse);
-      applyLocalVariableSemanticChanges(dartUniverse);
       new ConstructorSemanticProcessor(this).process(dartUniverse);
-      renameConstructors(dartUniverse);
       insertEnclosingTypeForInstanceCreationArguments(dartUniverse);
     }
     // done
     return dartUniverse;
   }
 
   /**
    * @return the "technical" name for the top-level Dart class for Java anonymous class.
    */
   int generateTechnicalAnonymousClassIndex() {
@@ skipping 310 matching lines @@
             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();
-        for (ClassMember member : members) {
-          if (member instanceof ConstructorDeclaration) {
-            numConstructors++;
-          }
-          if (member instanceof MethodDeclaration) {
-            String name = ((MethodDeclaration) member).getName().getName();
-            memberNamesInClass.add(name);
-          }
-          if (member instanceof FieldDeclaration) {
-            FieldDeclaration fieldDeclaration = (FieldDeclaration) member;
-            NodeList<VariableDeclaration> variables = fieldDeclaration.getFields().getVariables();
-            for (VariableDeclaration variable : variables) {
-              String name = variable.getName().getName();
-              memberNamesInClass.add(name);
-            }
-          }
-        }
-        return super.visitClassDeclaration(node);
-      }
-
-      @Override
-      public Void visitConstructorDeclaration(ConstructorDeclaration node) {
-        IMethodBinding binding = constructorToBinding.get(node);
-        String bindingSignature = JavaUtils.getJdtSignature(binding);
-        // prepare name
-        String name = renameMap.get(bindingSignature);
-        if (name == null) {
-          if (numConstructors == 1 || node.getParameters().getParameters().isEmpty()) {
-            // don't set name, use unnamed constructor
-          } else {
-            int index = 1;
-            while (true) {
-              name = "con" + index++;
-              if (!memberNamesInClass.contains(name)) {
-                break;
-              }
-            }
-          }
-        }
-        memberNamesInClass.add(name);
-        // apply name
-        if ("<empty>".equals(name)) {
-          name = null;
-        }
-        renameConstructor(node, name);
-        // continue
-        return super.visitConstructorDeclaration(node);
-      }
-    });
-  }
-
   private void renamePrivateClassMembers() {
     for (ClassMember member : privateClassMembers) {
       if (member instanceof FieldDeclaration) {
         FieldDeclaration fieldDeclaration = (FieldDeclaration) member;
         NodeList<VariableDeclaration> variables = fieldDeclaration.getFields().getVariables();
         for (VariableDeclaration field : variables) {
           SimpleIdentifier nameNode = field.getName();
           String name = nameNode.getName();
           renameIdentifier(nameNode, "_" + name);
         }
@@ skipping 78 matching lines @@
                   }
                 }
               }
             }
           }
         }
       }
     });
   }
 }