Simplify constructors translation, improve code style.

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 22 matching lines @@
 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.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;
@@ skipping 23 matching lines @@
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Context information for Java to Dart translation.
  */
 public class Context {
   /**
    * Information about constructor and its usages.
    */
-  class ConstructorDescription {
+  public static class ConstructorDescription {
     final IMethodBinding binding;
-    final List<SuperConstructorInvocation> superInvocations = Lists.newArrayList();
-    final List<InstanceCreationExpression> instanceCreations = Lists.newArrayList();
-    final List<SimpleIdentifier> implInvocations = Lists.newArrayList();
+    public final List<RedirectingConstructorInvocation> redirectingInvocations = Lists.newArrayList();
+    public final List<SuperConstructorInvocation> superInvocations = Lists.newArrayList();
+    public final List<InstanceCreationExpression> instanceCreations = Lists.newArrayList();
+    public boolean isEnum;
     String declName;
-    String implName;
 
     public ConstructorDescription(IMethodBinding binding) {
       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();
@@ skipping 428 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 the not <code>null</code> {@link ConstructorDescription}, may be just added.
+   */
+  public ConstructorDescription getConstructorDescription(IMethodBinding binding) {
+    ConstructorDescription description = bindingToConstructor.get(binding);
+    if (description == null) {
+      description = new ConstructorDescription(binding);
+      bindingToConstructor.put(binding, description);
+    }
+    return description;
+  }
+
   public Map<File, List<CompilationUnitMember>> getFileToMembers() {
     return fileToMembers;
   }
 
   /**
    * 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) {
@@ skipping 43 matching lines @@
     if (name == null) {
       newIdentifier = null;
     } else {
       newIdentifier = identifier(name);
     }
     // rename constructor
     node.setName(newIdentifier);
     // update references
     ConstructorDescription constructorDescription = bindingToConstructor.get(binding);
     if (constructorDescription != null) {
-      // set name in InstanceCreationExpression
+      // set name in RedirectingConstructorInvocation
       {
-        List<InstanceCreationExpression> creations = constructorDescription.instanceCreations;
-        for (InstanceCreationExpression creation : creations) {
-          creation.getConstructorName().setName(newIdentifier);
+        List<RedirectingConstructorInvocation> invocations = constructorDescription.redirectingInvocations;
+        for (RedirectingConstructorInvocation invocation : invocations) {
+          invocation.setConstructorName(newIdentifier);
         }
       }
       // set name in SuperConstructorInvocation
       {
         List<SuperConstructorInvocation> invocations = constructorDescription.superInvocations;
         for (SuperConstructorInvocation invocation : invocations) {
           invocation.setConstructorName(newIdentifier);
         }
       }
-      // set name in invocation of implementation
+      // set name in InstanceCreationExpression
       {
-        List<SimpleIdentifier> invocations = constructorDescription.implInvocations;
-        for (SimpleIdentifier identifier : invocations) {
-          identifier.setToken(token(TokenType.IDENTIFIER, constructorDescription.implName));
+        List<InstanceCreationExpression> creations = constructorDescription.instanceCreations;
+        for (InstanceCreationExpression creation : creations) {
+          creation.getConstructorName().setName(newIdentifier);
         }
       }
     }
   }
 
   /**
    * Sets the {@link SimpleIdentifier} name and updates all references.
    */
   public void renameIdentifier(SimpleIdentifier declarationIdentifier, String newName) {
     // move identifiers to the new signature
@@ skipping 24 matching lines @@
     }
     // run processors
     {
       replaceInnerClassReferences(dartUniverse);
       unwrapVarArgIfAlreadyArray(dartUniverse);
       ensureFieldInitializers(dartUniverse);
       dontUseThisInFieldInitializers(dartUniverse);
       ensureUniqueClassMemberNames(dartUniverse);
       ensureNoVariableNameReferenceFromInitializer(dartUniverse);
       ensureMethodParameterDoesNotHide(dartUniverse);
+      new ConstructorSemanticProcessor(this).process(dartUniverse);
       renameConstructors(dartUniverse);
     }
     // done
     return dartUniverse;
   }
 
   /**
    * @return the "technical" name for the top-level Dart class for Java anonymous class.
    */
   int generateTechnicalAnonymousClassIndex() {
     return technicalAnonymousClassIndex++;
   }
 
   /**
    * @return the "technical" name for the Dart constructor.
    */
   String generateTechnicalConstructorName() {
     return "jtd_constructor_" + technicalConstructorIndex++;
   }
 
   /**
    * @return the "technical" name for the top-level Dart class for Java inner class.
    */
   String generateTechnicalInnerClassName() {
     return "JtdClass_" + technicalInnerClassIndex++;
   }
 
   /**
-   * @return the not <code>null</code> {@link ConstructorDescription}, may be just added.
-   */
-  ConstructorDescription getConstructorDescription(IMethodBinding binding) {
-    ConstructorDescription description = bindingToConstructor.get(binding);
-    if (description == null) {
-      description = new ConstructorDescription(binding);
-      bindingToConstructor.put(binding, description);
-    }
-    return description;
-  }
-
-  /**
    * Remembers artificial {@link ClassDeclaration} created for Java creation of anonymous class
    * declaration.
    */
   void putAnonymousDeclaration(InstanceCreationExpression creation, ClassDeclaration declaration) {
     if (declaration != null) {
       anonymousDeclarations.put(creation, declaration);
     }
   }
 
   /**
@@ skipping 98 matching lines @@
                 return super.visitThisExpression(node);
               }
             });
             return result.get();
           }
         });
         // add field assignment for each "this" field initializer
         if (thisInitializers.isEmpty()) {
           return;
         }
-        ConstructorDeclaration singleConstructor = null;
-        boolean hasImpl = false;
+        boolean hasConstructor = false;
         for (ClassMember classMember : classDeclaration.getMembers()) {
           if (classMember instanceof ConstructorDeclaration) {
-            singleConstructor = (ConstructorDeclaration) classMember;
-          }
-          if (classMember instanceof MethodDeclaration) {
-            MethodDeclaration method = (MethodDeclaration) classMember;
-            String methodName = method.getName().getName();
-            if (methodName.startsWith("_jtd_constructor_") && methodName.endsWith("_impl")) {
-              hasImpl = true;
-              Block block = ((BlockFunctionBody) method.getBody()).getBlock();
-              addAssignmentsToBlock(block, thisInitializers);
-            }
+            ConstructorDeclaration constructor = (ConstructorDeclaration) classMember;
+            hasConstructor = true;
+            Block block = ((BlockFunctionBody) constructor.getBody()).getBlock();
+            addAssignmentsToBlock(block, thisInitializers);
           }
         }
-        // no "_impl", add assignments to the single constructor
-        if (!hasImpl && singleConstructor != null) {
-          Block block = ((BlockFunctionBody) singleConstructor.getBody()).getBlock();
-          addAssignmentsToBlock(block, thisInitializers);
-        }
-        // no "_impl", generate default constructor
-        if (singleConstructor == null) {
+        // no constructors, generate default constructor
+        if (!hasConstructor) {
           Block block = block();
           addAssignmentsToBlock(block, thisInitializers);
           ConstructorDeclaration constructor = constructorDeclaration(
               classDeclaration.getName(),
               null,
               formalParameterList(),
               null,
               blockFunctionBody(block));
           classDeclaration.getMembers().add(constructor);
         }
@@ skipping 230 matching lines @@
                   }
                 }
               }
             }
           }
         }
       }
     });
   }
 }