* Copyright (C) 2010-2011 The Project Lombok Authors.

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

*/

* Turns {@code lombok.ast} based ASTs into eclipse/ecj's {@code org.eclipse.jdt.internal.compiler.ast.ASTNode} model.

*/

  private static final int VISIBILITY_MASK = 7;

  static final char[] PACKAGE_INFO = "package-info".toCharArray();

 

  private final Map<lombok.ast.Node, Collection<SourceStructure>> sourceStructures;

  private List<? extends ASTNode> result = null;

  private final String rawInput;

  private final ProblemReporter reporter;

  private final ProblemReporter silentProblemReporter;

  private final CompilationResult compilationResult;

  private final CompilerOptions options;

  private final EnumSet<BubblingFlags> bubblingFlags = EnumSet.noneOf(BubblingFlags.class);

  private final EnumSet<BubblingFlags> AUTO_REMOVABLE_BUBBLING_FLAGS = EnumSet.of(BubblingFlags.LOCALTYPE);

 

  private enum BubblingFlags {

    ASSERT, LOCALTYPE, ABSTRACT_METHOD

  }

 

  private enum VariableKind {

    UNSUPPORTED {

      AbstractVariableDeclaration create() {

        throw new UnsupportedOperationException();

      }

    },

    FIELD {

      AbstractVariableDeclaration create() {

        return new FieldDeclaration();

      }

    },

    LOCAL {

      AbstractVariableDeclaration create() {

        return new LocalDeclaration(null, 0, 0);

      }

    },

    ARGUMENT {

      AbstractVariableDeclaration create() {

        return new Argument(null, 0, null, 0);

      }

    };

   

    abstract AbstractVariableDeclaration create();

   

    static VariableKind kind(lombok.ast.VariableDefinition node) {

      //TODO rewrite this whole thing.

      lombok.ast.Node parent = node.getParent();

      if (parent instanceof lombok.ast.VariableDeclaration) {

        if (parent.getParent() instanceof lombok.ast.TypeBody ||

          parent.getParent() instanceof lombok.ast.EnumTypeBody) {

          return FIELD;

        } else {

          return LOCAL;

        }

      }

      if (parent instanceof lombok.ast.For ||

        parent instanceof lombok.ast.ForEach){

        return LOCAL;

      }

      if (parent instanceof lombok.ast.Catch ||

        parent instanceof lombok.ast.MethodDeclaration ||

        parent instanceof lombok.ast.ConstructorDeclaration){

        return ARGUMENT;

      }

      return UNSUPPORTED;

    }

  }

 

  private static final IProblemFactory SILENT_PROBLEM_FACTORY = new IProblemFactory() {

   

    @Override public String getLocalizedMessage(int problemId, int elaborationId, String[] messageArguments) {

      return null;

    }

   

    @Override public String getLocalizedMessage(int problemId, String[] messageArguments) {

      return null;

    }

   

    @Override public Locale getLocale() {

      return Locale.getDefault();

    }

   

    @Override public CategorizedProblem createProblem(char[] originatingFileName, int problemId, String[] problemArguments, int elaborationId, String[] messageArguments, int severity, int startPosition, int endPosition, int lineNumber, int columnNumber) {

      return null;

    }

   

    @Override public CategorizedProblem createProblem(char[] originatingFileName, int problemId, String[] problemArguments, String[] messageArguments, int severity, int startPosition, int endPosition, int lineNumber, int columnNumber) {

      return null;

    }

  };

 

  public EcjTreeBuilder(lombok.ast.grammar.Source source, CompilerOptions options) {

    this(source, createDefaultProblemReporter(options), createSilentProblemReporter(options), new CompilationResult(source.getName().toCharArray(), 0, 0, 0));

  }

 

  public EcjTreeBuilder(String rawInput, String name, CompilerOptions options) {

    this(rawInput, createDefaultProblemReporter(options), createSilentProblemReporter(options), new CompilationResult(name.toCharArray(), 0, 0, 0));

  }

 

  private static ProblemReporter createDefaultProblemReporter(CompilerOptions options) {

    return new ProblemReporter(new IErrorHandlingPolicy() {

      public boolean proceedOnErrors() {

        return true;

      }

     

      public boolean stopOnFirstError() {

        return false;

      }

    }, options, new DefaultProblemFactory(Locale.ENGLISH));

  }

 

  private static ProblemReporter createSilentProblemReporter(CompilerOptions options) {

    return new ProblemReporter(new IErrorHandlingPolicy() {

      public boolean proceedOnErrors() {

        return true;

      }

     

      public boolean stopOnFirstError() {

        return false;

      }

    }, options, SILENT_PROBLEM_FACTORY);

  }

 

  public EcjTreeBuilder(lombok.ast.grammar.Source source, ProblemReporter reporter, ProblemReporter silentProblemReporter, CompilationResult compilationResult) {

    this.options = reporter.options;

    this.sourceStructures = source.getSourceStructures();

    this.rawInput = source.getRawInput();

    this.reporter = reporter;

    this.silentProblemReporter = silentProblemReporter;

    this.compilationResult = compilationResult;

  }

 

  public EcjTreeBuilder(String rawInput, ProblemReporter reporter, ProblemReporter silentProblemReporter, CompilationResult compilationResult) {

    this.options = reporter.options;

    this.sourceStructures = null;

    this.rawInput = rawInput;

    this.reporter = reporter;

    this.silentProblemReporter = silentProblemReporter;

    this.compilationResult = compilationResult;

  }

 

  private EcjTreeBuilder(EcjTreeBuilder parent) {

    this.reporter = parent.reporter;

    this.silentProblemReporter = parent.silentProblemReporter;

    this.options = parent.options;

    this.rawInput = parent.rawInput;

    this.compilationResult = parent.compilationResult;

    this.sourceStructures = parent.sourceStructures;

  }

 

  private EcjTreeBuilder create() {

    return new EcjTreeBuilder(this);

  }

 

  private Expression toExpression(lombok.ast.Node node) {

    return (Expression) toTree(node);

  }

 

  private Statement toStatement(lombok.ast.Node node) {

    return (Statement) toTree(node);

  }

 

  private ASTNode toTree(lombok.ast.Node node) {

    if (node == null) return null;

    EcjTreeBuilder newBuilder = create();

    node.accept(newBuilder.visitor);

    bubblingFlags.addAll(newBuilder.bubblingFlags);

    try {

      return newBuilder.get();

    } catch (RuntimeException e) {

      System.err.printf("Node '%s' (%s) did not produce any results\n", node, node.getClass().getSimpleName());

      throw e;

    }

  }

 

  private char[] toName(lombok.ast.Identifier node) {

    if (node == null) {

      return null;

    }

    return node.astValue().toCharArray();

  }

 

  private <T extends ASTNode> T[] toArray(Class<T> type, List<T> list) {

    if (list.isEmpty()) return null;

    @SuppressWarnings("unchecked")

    T[] emptyArray = (T[]) Array.newInstance(type, 0);

    return list.toArray(emptyArray);

  }

 

  private <T extends ASTNode> T[] toArray(Class<T> type, lombok.ast.Node node) {

    return toArray(type, toList(type, node));

  }

 

  private <T extends ASTNode> T[] toArray(Class<T> type, lombok.ast.StrictListAccessor<?, ?> accessor) {

    List<T> list = Lists.newArrayList();

    for (lombok.ast.Node node : accessor) {

      EcjTreeBuilder newBuilder = create();

      node.accept(newBuilder.visitor);

      bubblingFlags.addAll(newBuilder.bubblingFlags);

     

      List<? extends ASTNode> values;

     

      values = newBuilder.getAll();

     

      for (ASTNode value : values) {

        if (value != null && !type.isInstance(value)) {

          throw new ClassCastException(value.getClass().getName() + " cannot be cast to " + type.getName());

        }

        list.add(type.cast(value));

      }

    }

   

    return toArray(type, list);

  }

 

  private <T extends ASTNode> List<T> toList(Class<T> type, lombok.ast.Node node) {

    if (node == null) return Lists.newArrayList();

    EcjTreeBuilder newBuilder = create();

    node.accept(newBuilder.visitor);

    bubblingFlags.addAll(newBuilder.bubblingFlags);

    @SuppressWarnings("unchecked")

    List<T> all = (List<T>)newBuilder.getAll();

    return Lists.newArrayList(all);

  }

 

  public void visit(lombok.ast.Node node) {

    node.accept(visitor);

  }

 

  public ASTNode get() {

    if (result.isEmpty()) {

      return null;

    }

    if (result.size() == 1) {

      return result.get(0);

    }

    throw new RuntimeException("Expected only one result but got " + result.size());

  }

 

  public List<? extends ASTNode> getAll() {

    return result;

  }

 

  private static <T extends ASTNode> T posParen(T in, lombok.ast.Node node) {

    if (in == null) return null;

    if (node instanceof lombok.ast.Expression) {

      List<Position> parensPositions = ((lombok.ast.Expression)node).astParensPositions();

      if (!parensPositions.isEmpty()) {

        in.sourceStart = parensPositions.get(parensPositions.size() - 1).getStart();

        in.sourceEnd = parensPositions.get(parensPositions.size() - 1).getEnd() - 1;

      }

    }

   

    return in;

  }

 

  private static boolean isExplicitlyAbstract(Modifiers m) {

    for (KeywordModifier keyword : m.astKeywords()) {

      if ("abstract".equals(keyword.astName())) return true;

    }

    return false;

  }

 

  private static final EnumMap<UnaryOperator, Integer> UNARY_OPERATORS = Maps.newEnumMap(UnaryOperator.class);

  static {

    UNARY_OPERATORS.put(UnaryOperator.BINARY_NOT, OperatorIds.TWIDDLE);

    UNARY_OPERATORS.put(UnaryOperator.LOGICAL_NOT, OperatorIds.NOT);

    UNARY_OPERATORS.put(UnaryOperator.UNARY_PLUS, OperatorIds.PLUS);

    UNARY_OPERATORS.put(UnaryOperator.PREFIX_INCREMENT, OperatorIds.PLUS);

    UNARY_OPERATORS.put(UnaryOperator.UNARY_MINUS, OperatorIds.MINUS);

    UNARY_OPERATORS.put(UnaryOperator.PREFIX_DECREMENT, OperatorIds.MINUS);

    UNARY_OPERATORS.put(UnaryOperator.POSTFIX_INCREMENT, OperatorIds.PLUS);

    UNARY_OPERATORS.put(UnaryOperator.POSTFIX_DECREMENT, OperatorIds.MINUS);

  }

 

  private static final EnumMap<BinaryOperator, Integer> BINARY_OPERATORS = Maps.newEnumMap(BinaryOperator.class);

  static {

    BINARY_OPERATORS.put(BinaryOperator.PLUS_ASSIGN, OperatorIds.PLUS);

    BINARY_OPERATORS.put(BinaryOperator.MINUS_ASSIGN, OperatorIds.MINUS);

    BINARY_OPERATORS.put(BinaryOperator.MULTIPLY_ASSIGN, OperatorIds.MULTIPLY);

    BINARY_OPERATORS.put(BinaryOperator.DIVIDE_ASSIGN, OperatorIds.DIVIDE);

    BINARY_OPERATORS.put(BinaryOperator.REMAINDER_ASSIGN, OperatorIds.REMAINDER);

    BINARY_OPERATORS.put(BinaryOperator.AND_ASSIGN, OperatorIds.AND);

    BINARY_OPERATORS.put(BinaryOperator.XOR_ASSIGN, OperatorIds.XOR);

    BINARY_OPERATORS.put(BinaryOperator.OR_ASSIGN, OperatorIds.OR);

    BINARY_OPERATORS.put(BinaryOperator.SHIFT_LEFT_ASSIGN, OperatorIds.LEFT_SHIFT);

    BINARY_OPERATORS.put(BinaryOperator.SHIFT_RIGHT_ASSIGN, OperatorIds.RIGHT_SHIFT);

    BINARY_OPERATORS.put(BinaryOperator.BITWISE_SHIFT_RIGHT_ASSIGN, OperatorIds.UNSIGNED_RIGHT_SHIFT);

    BINARY_OPERATORS.put(BinaryOperator.LOGICAL_OR, OperatorIds.OR_OR);

    BINARY_OPERATORS.put(BinaryOperator.LOGICAL_AND, OperatorIds.AND_AND);

    BINARY_OPERATORS.put(BinaryOperator.BITWISE_OR, OperatorIds.OR);

    BINARY_OPERATORS.put(BinaryOperator.BITWISE_XOR, OperatorIds.XOR);

    BINARY_OPERATORS.put(BinaryOperator.BITWISE_AND, OperatorIds.AND);

    BINARY_OPERATORS.put(BinaryOperator.EQUALS, OperatorIds.EQUAL_EQUAL);

    BINARY_OPERATORS.put(BinaryOperator.NOT_EQUALS, OperatorIds.NOT_EQUAL);

    BINARY_OPERATORS.put(BinaryOperator.GREATER, OperatorIds.GREATER);

    BINARY_OPERATORS.put(BinaryOperator.GREATER_OR_EQUAL, OperatorIds.GREATER_EQUAL);

    BINARY_OPERATORS.put(BinaryOperator.LESS, OperatorIds.LESS);

    BINARY_OPERATORS.put(BinaryOperator.LESS_OR_EQUAL, OperatorIds.LESS_EQUAL);

    BINARY_OPERATORS.put(BinaryOperator.SHIFT_LEFT, OperatorIds.LEFT_SHIFT);

    BINARY_OPERATORS.put(BinaryOperator.SHIFT_RIGHT, OperatorIds.RIGHT_SHIFT);

    BINARY_OPERATORS.put(BinaryOperator.BITWISE_SHIFT_RIGHT, OperatorIds.UNSIGNED_RIGHT_SHIFT);

    BINARY_OPERATORS.put(BinaryOperator.PLUS, OperatorIds.PLUS);

    BINARY_OPERATORS.put(BinaryOperator.MINUS, OperatorIds.MINUS);

    BINARY_OPERATORS.put(BinaryOperator.MULTIPLY, OperatorIds.MULTIPLY);

    BINARY_OPERATORS.put(BinaryOperator.DIVIDE, OperatorIds.DIVIDE);

    BINARY_OPERATORS.put(BinaryOperator.REMAINDER, OperatorIds.REMAINDER);

  }

 

  private final AstVisitor visitor = new ForwardingAstVisitor() {

    @Override

    public boolean visitCompilationUnit(lombok.ast.CompilationUnit node) {

      int sourceLength = rawInput == null ? 0 : rawInput.length();

      CompilationUnitDeclaration cud = new CompilationUnitDeclaration(reporter, compilationResult, sourceLength);

      cud.bits |= ASTNode.HasAllMethodBodies;

     

      cud.currentPackage = (ImportReference) toTree(node.astPackageDeclaration());

      cud.imports = toArray(ImportReference.class, node.astImportDeclarations());

      cud.types = toArray(TypeDeclaration.class, node.astTypeDeclarations());

     

      if (CharOperation.equals(PACKAGE_INFO, cud.getMainTypeName())) {

        TypeDeclaration[] newTypes;

        if (cud.types == null) {

          newTypes = new TypeDeclaration[1];

        } else {

          newTypes = new TypeDeclaration[cud.types.length + 1];

          System.arraycopy(cud.types, 0, newTypes, 1, cud.types.length);

        }

        TypeDeclaration decl = new TypeDeclaration(compilationResult);

        decl.name = PACKAGE_INFO.clone();

        decl.modifiers = ClassFileConstants.AccDefault | ClassFileConstants.AccInterface;

       

        newTypes[0] = decl;

        cud.types = newTypes;

       

        lombok.ast.PackageDeclaration pkgDeclaration = node.astPackageDeclaration();

        Comment javadoc = pkgDeclaration == null ? null : pkgDeclaration.astJavadoc();

        if (javadoc != null) {

          boolean markDep = javadoc.isMarkedDeprecated();

          cud.javadoc = (Javadoc) toTree(javadoc);

          if (markDep) decl.modifiers |= ClassFileConstants.AccDeprecated;

          decl.javadoc = cud.javadoc;

        }

      }

     

      bubblingFlags.remove(BubblingFlags.ASSERT);

      bubblingFlags.removeAll(AUTO_REMOVABLE_BUBBLING_FLAGS);

      if (!bubblingFlags.isEmpty()) {

        throw new RuntimeException("Unhandled bubbling flags left: " + bubblingFlags);

      }

      return set(node, cud);

    }

   

    private boolean set(lombok.ast.Node node, ASTNode value) {

      if (result != null) throw new IllegalStateException("result is already set");

     

      if (node instanceof lombok.ast.Expression) {

        int parens = ((lombok.ast.Expression)node).getIntendedParens();

        value.bits |= (parens << ASTNode.ParenthesizedSHIFT) & ASTNode.ParenthesizedMASK;

        posParen(value, node);

      }

      if (value instanceof NameReference) {

        updateRestrictionFlags(node, (NameReference)value);

      }

      List<ASTNode> result = Lists.newArrayList();

      if (value != null) result.add(value);

      EcjTreeBuilder.this.result = result;

     

      return true;

    }

   

    private boolean set(lombok.ast.Node node, List<? extends ASTNode> values) {

      if (values.isEmpty()) System.err.printf("Node '%s' (%s) did not produce any results\n", node, node.getClass().getSimpleName());

     

      if (result != null) throw new IllegalStateException("result is already set");

      result = values;

      return true;

    }

   

    private int calculateExplicitDeclarations(Iterable<lombok.ast.Statement> statements) {

      int explicitDeclarations = 0;

      if (statements != null) {

        for (lombok.ast.Statement s : statements) {

          if (s instanceof lombok.ast.VariableDeclaration) explicitDeclarations++;

          if (s instanceof lombok.ast.ClassDeclaration) explicitDeclarations++;

        }

      }

     

      return explicitDeclarations;

    }

   

    @Override

    public boolean visitPackageDeclaration(lombok.ast.PackageDeclaration node) {

      long[] pos = partsToPosArray(node.rawParts());

      ImportReference pkg = new ImportReference(chain(node.astParts()), pos, true, ClassFileConstants.AccDefault);

      pkg.annotations = toArray(Annotation.class, node.astAnnotations());

      pkg.declarationSourceStart = jstart(node);

      pkg.declarationSourceEnd = pkg.declarationEnd = end(node);

     

      return set(node, pkg);

    }

   

    //TODO Create a test file with a whole bunch of comments. Possibly in a separate non-idempotency subdir, as printing comments idempotently is a rough nut to crack.

   

    @Override

    public boolean visitImportDeclaration(lombok.ast.ImportDeclaration node) {

      int staticFlag = node.astStaticImport() ? ClassFileConstants.AccStatic : ClassFileConstants.AccDefault;

      long[] pos = partsToPosArray(node.rawParts());

      ImportReference imp = new ImportReference(chain(node.astParts()), pos, node.astStarImport(), staticFlag);

      imp.declarationSourceStart = start(node);

      imp.declarationSourceEnd = imp.declarationEnd = end(node);

      return set(node, imp);

    }

   

    @Override

    public boolean visitClassDeclaration(lombok.ast.ClassDeclaration node) {

      TypeDeclaration decl = createTypeBody(node.astBody().astMembers(), node, true, 0);

     

      decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations());

      decl.superclass = (TypeReference) toTree(node.astExtending());

      decl.superInterfaces = toArray(TypeReference.class, node.astImplementing());

     

      markTypeReferenceIsSuperType(decl);

     

      decl.typeParameters = toArray(TypeParameter.class, node.astTypeVariables());

     

      decl.name = toName(node.astName());

     

      updateTypeBits(node.getParent(), decl, false);

     

      setupJavadoc(decl, node);

     

      //TODO test inner types. Give em everything - (abstract) methods, initializers, static initializers, MULTIPLE initializers.

      return set(node, decl);

    }

   

    private void updateTypeBits(lombok.ast.Node parent, TypeDeclaration decl, boolean isEnum) {

      if (parent == null) {

        return;

      }

      if (parent instanceof lombok.ast.CompilationUnit) {

        char[] mainTypeName = new CompilationUnitDeclaration(reporter, compilationResult, 0).getMainTypeName();

        if (!CharOperation.equals(decl.name, mainTypeName)) {

          decl.bits |= ASTNode.IsSecondaryType;

        }

        return;

      }

     

      if (parent instanceof lombok.ast.TypeBody ||

        parent instanceof lombok.ast.EnumTypeBody) {

        decl.bits |= ASTNode.IsMemberType;

        return;

      }

     

      //TODO test if a type declared in an enum constant is possible

      decl.bits |= ASTNode.IsLocalType;

      bubblingFlags.add(BubblingFlags.LOCALTYPE);

    }

   

    private void markTypeReferenceIsSuperType(TypeDeclaration decl) {

      if (decl.superclass != null) {

        decl.superclass.bits |= ASTNode.IsSuperType;

      }

      if (decl.superInterfaces != null) {

        for (TypeReference t : decl.superInterfaces) {

          t.bits |= ASTNode.IsSuperType;

        }

      }

    }

   

   

    @Override

    public boolean visitInterfaceDeclaration(lombok.ast.InterfaceDeclaration node) {

      TypeDeclaration decl = createTypeBody(node.astBody().astMembers(), node, false, ClassFileConstants.AccInterface);

     

      decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations());

      decl.superInterfaces = toArray(TypeReference.class, node.astExtending());

     

      markTypeReferenceIsSuperType(decl);

     

      decl.typeParameters = toArray(TypeParameter.class, node.astTypeVariables());

      decl.name = toName(node.astName());

     

      updateTypeBits(node.getParent(), decl, false);

     

      setupJavadoc(decl, node);

     

      return set(node, decl);

    } 

   

    @Override

    public boolean visitEnumDeclaration(lombok.ast.EnumDeclaration node) {

      FieldDeclaration[] fields = null;

     

      if (node.astBody() != null) {

        fields = toArray(FieldDeclaration.class, node.astBody().astConstants());

      }

      TypeDeclaration decl = createTypeBody(node.astBody().astMembers(), node, true, ClassFileConstants.AccEnum, fields);

     

      decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations());

      decl.superInterfaces = toArray(TypeReference.class, node.astImplementing());

     

      markTypeReferenceIsSuperType(decl);

     

      decl.name = toName(node.astName());

     

      updateTypeBits(node.getParent(), decl, true);

     

      setupJavadoc(decl, node);

     

      return set(node, decl);

    }

   

    @Override

    public boolean visitEnumConstant(lombok.ast.EnumConstant node) {

      //TODO check where the javadoc and annotations go: the field or the type

     

      FieldDeclaration decl = new FieldDeclaration();

      decl.annotations = toArray(Annotation.class, node.astAnnotations());

      decl.name = toName(node.astName());

     

      decl.sourceStart = start(node.astName());

      decl.sourceEnd = end(node.astName());

      decl.declarationSourceStart = decl.modifiersSourceStart = jstart(node);

      decl.declarationSourceEnd = decl.declarationEnd = end(node);

      Position ecjDeclarationSourcePos = getConversionPositionInfo(node, "declarationSource");

      if (ecjDeclarationSourcePos != null) decl.declarationSourceEnd = ecjDeclarationSourcePos.getEnd() - 1;

     

      AllocationExpression init;

      if (node.astBody() == null) {

        init = new AllocationExpression();

        init.enumConstant = decl;

      } else {

        TypeDeclaration type = createTypeBody(node.astBody().astMembers(), null, false, 0);

        type.sourceStart = type.sourceEnd = start(node.astBody());

        type.bodyEnd--;

        type.declarationSourceStart = type.sourceStart;

        type.declarationSourceEnd = end(node);

        type.name = CharOperation.NO_CHAR;

        type.bits &= ~ASTNode.IsMemberType;

        decl.bits |= ASTNode.HasLocalType;

        type.bits |= ASTNode.IsLocalType | ASTNode.IsAnonymousType;

        init = new QualifiedAllocationExpression(type);

        init.enumConstant = decl;

      }

      init.arguments = toArray(Expression.class, node.astArguments());

      decl.initialization = init;

     

      if (bubblingFlags.remove(BubblingFlags.LOCALTYPE)) {

        decl.bits |= ASTNode.HasLocalType;

      }

     

      setupJavadoc(decl, node);

     

      return set(node, decl);

    }

   

    @Override

    public boolean visitAnnotationDeclaration(lombok.ast.AnnotationDeclaration node) {

      TypeDeclaration decl = createTypeBody(node.astBody().astMembers(), node, false,

          ClassFileConstants.AccAnnotation | ClassFileConstants.AccInterface);

      decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations());

      decl.name = toName(node.astName());

      updateTypeBits(node.getParent(), decl, false);

     

      setupJavadoc(decl, node);

     

      return set(node, decl);

    }

   

    private void setupJavadoc(ASTNode node, lombok.ast.JavadocContainer container) {

      if (container != null && container.rawJavadoc() instanceof lombok.ast.Comment) {

        lombok.ast.Comment javadoc = (Comment) container.rawJavadoc();

        boolean markDep = javadoc.isMarkedDeprecated();

       

        if (node instanceof AbstractMethodDeclaration) {

          AbstractMethodDeclaration decl = (AbstractMethodDeclaration) node;

          decl.javadoc = (Javadoc) toTree(javadoc);

          if (markDep) decl.modifiers |= ClassFileConstants.AccDeprecated;

        }

        if (node instanceof FieldDeclaration) {

          FieldDeclaration decl = (FieldDeclaration) node;

          decl.javadoc = (Javadoc) toTree(javadoc);

          if (markDep) decl.modifiers |= ClassFileConstants.AccDeprecated;

        }

        if (node instanceof TypeDeclaration) {

          TypeDeclaration decl = (TypeDeclaration) node;

          decl.javadoc = (Javadoc) toTree(javadoc);

          if (markDep) decl.modifiers |= ClassFileConstants.AccDeprecated;

        }

      }

    }

   

    @Override

    public boolean visitConstructorDeclaration(lombok.ast.ConstructorDeclaration node) {

      ConstructorDeclaration decl = new ConstructorDeclaration(compilationResult);

      decl.bodyStart = start(node.rawBody()) + 1;

      decl.bodyEnd = end(node.rawBody()) - 1;

      decl.declarationSourceStart = jstart(node);

      decl.declarationSourceEnd = end(node);

      decl.sourceStart = start(node.astTypeName());

      /* set sourceEnd */ {

        Position ecjPos = getConversionPositionInfo(node, "signature");

        decl.sourceEnd = ecjPos == null ? posOfStructure(node, ")", false) - 1 : ecjPos.getEnd() - 1;

       

        if (!node.rawThrownTypeReferences().isEmpty()) {

          decl.sourceEnd = end(node.rawThrownTypeReferences().last());

        }

      }

      decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations());

      decl.modifiers = toModifiers(node.astModifiers());

      decl.typeParameters = toArray(TypeParameter.class, node.astTypeVariables());

      decl.arguments = toArray(Argument.class, node.astParameters());

      decl.thrownExceptions = toArray(TypeReference.class, node.astThrownTypeReferences());

      decl.statements = toArray(Statement.class, node.astBody().astContents());

      decl.selector = toName(node.astTypeName());

     

      setupJavadoc(decl, node);

     

      if (decl.statements == null || decl.statements.length == 0 || !(decl.statements[0] instanceof ExplicitConstructorCall)) {

        decl.constructorCall = new ExplicitConstructorCall(ExplicitConstructorCall.ImplicitSuper);

        decl.constructorCall.sourceStart = decl.sourceStart;

        decl.constructorCall.sourceEnd = decl.sourceEnd;

      } else {

        //TODO check how super() and this() work

        decl.constructorCall = (ExplicitConstructorCall)decl.statements[0];

        if (decl.statements.length > 1) {

          Statement[] newStatements = new Statement[decl.statements.length - 1];

          System.arraycopy(decl.statements, 1, newStatements, 0, newStatements.length);

          decl.statements = newStatements;

        } else {

          decl.statements = null;

        }

      }

     

      if (bubblingFlags.remove(BubblingFlags.LOCALTYPE)) {

        decl.bits |= ASTNode.HasLocalType;

      }

     

      // Unlike other method(-like) constructs, while ConstructorDeclaration has a

      // explicitDeclarations field, its kept at 0, so we don't need to calculate that value here.

     

      if (isUndocumented(node.astBody())) decl.bits |= ASTNode.UndocumentedEmptyBlock;

     

      setupJavadoc(decl, node);

     

      return set(node, decl);

    }

   

    @Override

    public boolean visitMethodDeclaration(lombok.ast.MethodDeclaration node) {

      MethodDeclaration decl = new MethodDeclaration(compilationResult);

      decl.declarationSourceStart = jstart(node);

      decl.declarationSourceEnd = end(node);

      decl.sourceStart = start(node.astMethodName());

      boolean setOriginalPosOnType = false;

      /* set sourceEnd */ {

        Position ecjPos = getConversionPositionInfo(node, "signature");

        decl.sourceEnd = ecjPos == null ? posOfStructure(node, ")", false) - 1: ecjPos.getEnd() - 1;

        if (countStructure(node, "]") > 0) {

          decl.sourceEnd = posOfStructure(node, "]", false) - 1;

          setOriginalPosOnType = true;

        }

       

        if (!node.rawThrownTypeReferences().isEmpty()) {

          decl.sourceEnd = end(node.rawThrownTypeReferences().last());

        }

      }

      if (node.rawBody() == null) {

        decl.bodyStart = decl.sourceEnd + 1;

        decl.bodyEnd = end(node) - 1;

      } else {

        decl.bodyStart = start(node.rawBody()) + 1;

        decl.bodyEnd = end(node.rawBody()) - 1;

      }

      decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations());

      decl.modifiers = toModifiers(node.astModifiers());

      decl.returnType = (TypeReference) toTree(node.astReturnTypeReference());

      if (setOriginalPosOnType) {

        if (decl.returnType instanceof ArrayTypeReference) {

          ((ArrayTypeReference)decl.returnType).originalSourceEnd = end(node.rawReturnTypeReference());

        }

      }

      decl.typeParameters = toArray(TypeParameter.class, node.astTypeVariables());

      decl.arguments = toArray(Argument.class, node.astParameters());

      decl.selector = toName(node.astMethodName());

      decl.thrownExceptions = toArray(TypeReference.class, node.astThrownTypeReferences());

      if (node.astBody() == null) {

        decl.modifiers |= ExtraCompilerModifiers.AccSemicolonBody;

      } else {

        decl.statements = toArray(Statement.class, node.astBody().astContents());

        decl.explicitDeclarations = calculateExplicitDeclarations(node.astBody().astContents());

      }

     

      if (bubblingFlags.remove(BubblingFlags.LOCALTYPE)) {

        decl.bits |= ASTNode.HasLocalType;

      }

     

      if (isExplicitlyAbstract(node.astModifiers())) {

        bubblingFlags.add(BubblingFlags.ABSTRACT_METHOD);

      }

      if (isUndocumented(node.astBody())) decl.bits |= ASTNode.UndocumentedEmptyBlock;

     

      setupJavadoc(decl, node);

     

      return set(node, decl);

    }

   

    @Override

    public boolean visitAnnotationMethodDeclaration(lombok.ast.AnnotationMethodDeclaration node) {

      AnnotationMethodDeclaration decl = new AnnotationMethodDeclaration(compilationResult);

      decl.modifiers = toModifiers(node.astModifiers()) + ExtraCompilerModifiers.AccSemicolonBody;

      decl.declarationSourceStart = jstart(node);

      decl.declarationSourceEnd = end(node);

      decl.sourceStart = start(node.astMethodName());

      boolean setOriginalPosOnType = false;

      /* set sourceEnd */ {

        Position ecjSigPos = getConversionPositionInfo(node, "signature");

        Position ecjExtDimPos = getConversionPositionInfo(node, "extendedDimensions");

        if (ecjSigPos != null && ecjExtDimPos != null) {

          decl.sourceEnd = ecjSigPos.getEnd() - 1;

          decl.extendedDimensions = ecjExtDimPos.getStart();

        } else {

          decl.sourceEnd = posOfStructure(node, ")", false) - 1;

          decl.extendedDimensions = countStructure(node, "]");

          if (decl.extendedDimensions > 0) {

            decl.sourceEnd = posOfStructure(node, "]", false) - 1;

            setOriginalPosOnType = true;

          }

        }

      }

      decl.bodyStart = end(node);

      decl.bodyEnd = end(node);

      if (node.astDefaultValue() != null) {

        decl.modifiers |= ClassFileConstants.AccAnnotationDefault;

      }

      decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations());

      decl.defaultValue = toExpression(node.astDefaultValue());

      decl.selector = toName(node.astMethodName());

      decl.returnType = (TypeReference) toTree(node.astReturnTypeReference());

      if (setOriginalPosOnType) {

        if (decl.returnType instanceof ArrayTypeReference) {

          ((ArrayTypeReference)decl.returnType).originalSourceEnd = end(node.rawReturnTypeReference());

        }

      }

     

      if (isExplicitlyAbstract(node.astModifiers())) {

        bubblingFlags.add(BubblingFlags.ABSTRACT_METHOD);

      }

     

      setupJavadoc(decl, node);

     

      return set(node, decl);

    }

   

    private TypeDeclaration createTypeBody(lombok.ast.StrictListAccessor<lombok.ast.TypeMember, ?> members, lombok.ast.TypeDeclaration type, boolean canHaveConstructor, int extraModifiers, FieldDeclaration... initialFields) {

      TypeDeclaration decl = new TypeDeclaration(compilationResult);

      decl.modifiers = (type == null ? 0 : toModifiers(type.astModifiers())) | extraModifiers;

      if (members.isEmpty() && isUndocumented(members.owner())) decl.bits |= ASTNode.UndocumentedEmptyBlock;

     

      if (type != null) {

        decl.sourceStart = start(type.astName());

        decl.sourceEnd = end(type.astName());

        decl.declarationSourceStart = jstart(type);

        decl.declarationSourceEnd = end(type);

        if (!(type instanceof AnnotationDeclaration) || !type.astModifiers().isEmpty() || type.rawJavadoc() != null) {

          decl.modifiersSourceStart = jstart(type.astModifiers());

        } else {

          decl.modifiersSourceStart = -1;

        }

      }

      decl.bodyStart = start(members.owner()) + 1;

      decl.bodyEnd = end(members.owner());

     

      boolean hasExplicitConstructor = false;