* Copyright (c) 2000, 2011 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

  private static final String RUN_METHOD_NAME = "___run"; //$NON-NLS-1$

  private static final String EVAL_METHOD_NAME = "___eval"; //$NON-NLS-1$

  private static final String EVAL_FIELD_NAME = "___field"; //$NON-NLS-1$

  private String[] fLocalVariableTypeNames;

  private String[] fLocalVariableNames;

  private String fCodeSnippet;

  private boolean fRightTypeFound;

  private boolean fCreateInAStaticMethod;

  private boolean fEvaluateNextEndTypeDeclaration;

  private String fError;

  private IType fType;

  private StringBuffer fSource;

  private String fLastTypeName;

  private String fCompilationUnitName;

  private int fSnippetStartPosition;

  private int fRunMethodStartOffset;

  private int fRunMethodLength;

  /**

   * Level of source code to generate (major, minor). For example 1 and 4

   * indicates 1.4.

   */

  private int fSourceMajorLevel;

  private int fSourceMinorLevel;

  private Set<String> fTypeParameters = new HashSet<String>();

  /**

   * if the <code>createInAnInstanceMethod</code> flag is set, the method

   * created which contains the code snippet is an no-static method, even if

   * <code>position</code> is in a static method.

   *

   * @param type

   *            the root {@link IType}

   * @param createInAStaticMethod

   *            if the source should be generated

   * @param localTypesNames

   *            the array of local type names

   * @param localVariables

   *            the listing of local variable names

   * @param codeSnippet

   *            the code snippet

   * @param sourceLevel

   *            the desired source level

   */

  public SourceBasedSourceGenerator(IType type,

      boolean createInAStaticMethod, String[] localTypesNames,

      String[] localVariables, String codeSnippet, String sourceLevel) {

    fRightTypeFound = false;

    fType = type;

    fLocalVariableTypeNames = localTypesNames;

    fLocalVariableNames = localVariables;

    fCodeSnippet = codeSnippet;

    fCreateInAStaticMethod = createInAStaticMethod;

    int index = sourceLevel.indexOf('.');

    String num = sourceLevel.substring(0, index);

    fSourceMajorLevel = Integer.valueOf(num).intValue();

    num = sourceLevel.substring(index + 1);

    fSourceMinorLevel = Integer.valueOf(num).intValue();

  }

  /**

   * Returns the generated source or <code>null</code> if no source can be

   * generated.

   *

   * @return returns the backing source from the generator

   */

  public String getSource() {

    if (fSource == null) {

      return null;

    }

    return fSource.toString();

  }

  public String getCompilationUnitName() {

    return fCompilationUnitName;

  }

  public int getSnippetStart() {

    return fSnippetStartPosition;

  }

  public int getRunMethodStart() {

    return fSnippetStartPosition - fRunMethodStartOffset;

  }

  public int getRunMethodLength() {

    return fRunMethodLength;

  }

  private boolean rightTypeFound() {

    return fRightTypeFound;

  }

  private void setRightTypeFound(boolean value) {

    fRightTypeFound = value;

  }

  public boolean hasError() {

    return fError != null;

  }

  public void setError(String errorDesc) {

    fError = errorDesc;

  }

  public String getError() {

    return fError;

  }

  private StringBuffer buildRunMethod(List<BodyDeclaration> bodyDeclarations) {

    StringBuffer buffer = new StringBuffer();

    if (fCreateInAStaticMethod) {

      buffer.append("static "); //$NON-NLS-1$

    }

    // add type parameters as required

    if (isSourceLevelGreaterOrEqual(1, 5)) {

      if (!fTypeParameters.isEmpty()) {

        Iterator<String> iterator = fTypeParameters.iterator();

        buffer.append(Signature.C_GENERIC_START);

        while (iterator.hasNext()) {

          String name = iterator.next();

          buffer.append(name);

          if (iterator.hasNext()) {

            buffer.append(", "); //$NON-NLS-1$

          }

        }

        buffer.append(Signature.C_GENERIC_END);

      }

    }

    buffer.append("void "); //$NON-NLS-1$

    buffer.append(getUniqueMethodName(RUN_METHOD_NAME, bodyDeclarations));

    buffer.append('(');

    for (int i = 0, length = fLocalVariableNames.length; i < length; i++) {

      buffer.append(getDotName(fLocalVariableTypeNames[i]));

      buffer.append(' ');

      buffer.append(fLocalVariableNames[i]);

      if (i + 1 < length)

        buffer.append(", "); //$NON-NLS-1$

    }

    buffer.append(") throws Throwable {"); //$NON-NLS-1$

    buffer.append('\n');

    fSnippetStartPosition = buffer.length() - 2;

    fRunMethodStartOffset = fSnippetStartPosition;

    String codeSnippet = new String(fCodeSnippet).trim();

    buffer.append(codeSnippet);

    buffer.append('\n');

    buffer.append('}').append('\n');

    fRunMethodLength = buffer.length();

    return buffer;

  }

  private String getDotName(String typeName) {

    return typeName.replace('$', '.');

  }

  /**

   * Returns if the specified {@link ASTNode} has the 'correct' parent type to

   * match the current type name context

   *

   * @param node

   *            the {@link ASTNode} to check source ranges for

   * @return true if the parent type of the given node matches the current

   *         type name context, false otherwise

   */

  private boolean isRightType(ASTNode node) {

    SourceRange range = new SourceRange(node.getStartPosition(),

        node.getLength());

    try {

      return fType.getSourceRange().equals(range);

    } catch (JavaModelException e) {

      JDIDebugPlugin.log(e.getStatus());

    }

    return false;

  }

  private StringBuffer buildTypeBody(StringBuffer buffer, List<BodyDeclaration> list) {

    StringBuffer source = new StringBuffer();

    source.append('{').append('\n');

    if (buffer != null) {

      fSnippetStartPosition += source.length();

    }

    source.append(buildBody(buffer, list));

    source.append('}').append('\n');

    return source;

  }

  private StringBuffer buildEnumBody(StringBuffer buffer,

      List<EnumConstantDeclaration> constantDeclarations, List<BodyDeclaration> bodyDeclarations) {

    StringBuffer source = new StringBuffer();

    source.append('{').append('\n');

    if (constantDeclarations.isEmpty()) {

      source.append(';').append('\n');

    } else {

      for (Iterator<EnumConstantDeclaration> iter = constantDeclarations.iterator(); iter

          .hasNext();) {

        source.append(iter.next().getName()

            .getIdentifier());

        if (iter.hasNext()) {

          source.append(',');

        } else {

          source.append(';');

        }

        source.append('\n');

      }

    }

    if (buffer != null) {

      fSnippetStartPosition += source.length();

    }

    source.append(buildBody(buffer, bodyDeclarations));

    source.append('}').append('\n');

    return source;

  }

  /**

   * Builds up the given buffer with the source from each of

   * {@link BodyDeclaration}s in the given list

   *

   * @param buffer

   *            the buffer to clone and append to

   * @param list

   *            the list of {@link BodyDeclaration}s

   * @return the new source buffer

   */

  private StringBuffer buildBody(StringBuffer buffer, List<BodyDeclaration> list) {

    StringBuffer source = new StringBuffer();

    if (buffer != null) {

      fSnippetStartPosition += source.length();

      source.append(buffer.toString());

    }

    for (Iterator<BodyDeclaration> iterator = list.iterator(); iterator.hasNext();) {

      BodyDeclaration bodyDeclaration = iterator.next();

      if (bodyDeclaration instanceof FieldDeclaration) {

        source.append(buildFieldDeclaration((FieldDeclaration) bodyDeclaration));

      } else if (bodyDeclaration instanceof MethodDeclaration) {

        source.append(buildMethodDeclaration((MethodDeclaration) bodyDeclaration));

      } else if (bodyDeclaration instanceof TypeDeclaration) {

        TypeDeclaration typeDeclaration = (TypeDeclaration) bodyDeclaration;

        if (!typeDeclaration.getName().getIdentifier()

            .equals(fLastTypeName)) {

          source.append(buildTypeDeclaration(null, typeDeclaration));

        }

      } else if (bodyDeclaration instanceof EnumDeclaration) {

        EnumDeclaration enumDeclaration = (EnumDeclaration) bodyDeclaration;

        if (!enumDeclaration.getName().getIdentifier()

            .equals(fLastTypeName)) {

          source.append(buildEnumDeclaration(null, enumDeclaration));

        }

      }

    }

    return source;

  }

  private StringBuffer buildFieldDeclaration(FieldDeclaration fieldDeclaration) {

    StringBuffer source = new StringBuffer();

    source.append(Flags.toString(fieldDeclaration.getModifiers()));

    source.append(' ');

    source.append(getDotName(getTypeName(fieldDeclaration.getType())));

    source.append(' ');

    boolean first = true;

    for (Iterator<VariableDeclarationFragment> iterator = fieldDeclaration.fragments().iterator(); iterator

        .hasNext();) {

      VariableDeclarationFragment variableDeclarationFragment = iterator

          .next();

      if (first) {

        first = false;

      } else {

        source.append(',');

      }

      source.append(variableDeclarationFragment.getName().getIdentifier());

      for (int i = 0, dim = variableDeclarationFragment

          .getExtraDimensions(); i < dim; i++) {

        source.append('[').append(']');

      }

    }

    source.append(';').append('\n');

    return source;

  }

  private StringBuffer buildMethodDeclaration(

      MethodDeclaration methodDeclaration) {

    StringBuffer source = new StringBuffer();

    int modifiers = methodDeclaration.getModifiers();

    source.append(Flags.toString(modifiers));

    source.append(' ');

    appendTypeParameters(source, methodDeclaration.typeParameters());

    boolean isConstructor = methodDeclaration.isConstructor();

    if (!isConstructor) {

      source.append(getDotName(getTypeName(methodDeclaration

          .getReturnType2())));

      source.append(' ');

    }

    source.append(methodDeclaration.getName().getIdentifier());

    source.append(' ').append('(');

    boolean first = true;

    for (Iterator<SingleVariableDeclaration> iterator = methodDeclaration.parameters().iterator(); iterator

        .hasNext();) {

      SingleVariableDeclaration singleVariableDeclaration = iterator

          .next();

      if (first) {

        first = false;

      } else {

        source.append(',');

      }

      source.append(getDotName(getTypeName(singleVariableDeclaration

          .getType())));

      if (singleVariableDeclaration.isVarargs()) {

        source.append("..."); //$NON-NLS-1$

      }

      source.append(' ');

      source.append(singleVariableDeclaration.getName().getIdentifier());

      appendExtraDimensions(source,

          singleVariableDeclaration.getExtraDimensions());

    }

    source.append(')');

    appendExtraDimensions(source, methodDeclaration.getExtraDimensions());

    first = true;

    for (Iterator<Name> iterator = methodDeclaration.thrownExceptions()

        .iterator(); iterator.hasNext();) {

      Name name = iterator.next();

      if (first) {

        first = false;

        source.append(" throws "); //$NON-NLS-1$

      } else {

        source.append(',');

      }

      source.append(getQualifiedIdentifier(name));

    }

    if (Flags.isAbstract(modifiers) || Flags.isNative(modifiers)) {

      // No body for abstract and native methods

      source.append(";\n"); //$NON-NLS-1$

    } else {

      source.append('{').append('\n');

      if (!isConstructor) {

        source.append(getReturnExpression(methodDeclaration

            .getReturnType2()));

      }

      source.append('}').append('\n');

    }

    return source;

  }

  private void appendExtraDimensions(StringBuffer source, int extraDimension) {

    if (extraDimension > 0) {

      source.append(' ');

      for (int i = 0; i < extraDimension; i++) {

        source.append("[]"); //$NON-NLS-1$

      }

    }

  }

  private StringBuffer buildEnumDeclaration(StringBuffer buffer,

      EnumDeclaration enumDeclaration) {

    StringBuffer source = new StringBuffer();

    source.append(Flags.toString(enumDeclaration.getModifiers()));

    source.append(" enum "); //$NON-NLS-1$

    source.append(enumDeclaration.getName().getIdentifier());

    Iterator<Type> iterator = enumDeclaration.superInterfaceTypes().iterator();

    if (iterator.hasNext()) {

      source.append(" implements "); //$NON-NLS-1$

      source.append(getTypeName(iterator.next()));

      while (iterator.hasNext()) {

        source.append(',');

        source.append(getTypeName(iterator.next()));

      }

    }

    if (buffer != null) {

      fSnippetStartPosition += source.length();

    }

    source.append(buildEnumBody(buffer, enumDeclaration.enumConstants(),

        enumDeclaration.bodyDeclarations()));

    return source;

  }

  private StringBuffer buildTypeDeclaration(StringBuffer buffer,

      TypeDeclaration typeDeclaration) {

    StringBuffer source = new StringBuffer();

    source.append(Flags.toString(typeDeclaration.getModifiers()));

    if (typeDeclaration.isInterface()) {

      source.append(" interface "); //$NON-NLS-1$

    } else {

      source.append(" class "); //$NON-NLS-1$

    }

    source.append(typeDeclaration.getName().getIdentifier());

    List<TypeParameter> typeParameters = typeDeclaration.typeParameters();

    if (!typeParameters.isEmpty() && isSourceLevelGreaterOrEqual(1, 5)) {

      source.append('<');

      Iterator<TypeParameter> iter = typeParameters.iterator();

      TypeParameter typeParameter = iter.next();

      source.append(typeParameter.getName().getIdentifier());

      List<Type> typeBounds = typeParameter.typeBounds();

      if (!typeBounds.isEmpty()) {

        source.append(" extends "); //$NON-NLS-1$

        Iterator<Type> iter2 = typeBounds.iterator();

        source.append(getTypeName(iter2.next()));

        while (iter2.hasNext()) {

          source.append('&');

          source.append(getTypeName(iter2.next()));

        }

      }

      while (iter.hasNext()) {

        source.append(',');

        typeParameter = iter.next();

        source.append(typeParameter.getName().getIdentifier());

        typeBounds = typeParameter.typeBounds();

        if (!typeBounds.isEmpty()) {

          source.append(" extends "); //$NON-NLS-1$

          Iterator<Type> iter2 = typeBounds.iterator();

          source.append(getTypeName(iter2.next()));

          while (iter2.hasNext()) {

            source.append('&');

            source.append(getTypeName(iter2.next()));

          }

        }

      }

      source.append('>');

    }

    Type superClass = typeDeclaration.getSuperclassType();

    if (superClass != null) {

      source.append(" extends "); //$NON-NLS-1$

      source.append(getTypeName(superClass));

    }

    Iterator<Type> iter = typeDeclaration.superInterfaceTypes().iterator();

    if (iter.hasNext()) {

      if (typeDeclaration.isInterface()) {

        source.append(" extends "); //$NON-NLS-1$

      } else {

        source.append(" implements "); //$NON-NLS-1$

      }

      source.append(getTypeName(iter.next()));

      while (iter.hasNext()) {

        source.append(',');

        source.append(getTypeName(iter.next()));

      }

    }

    if (buffer != null) {

      fSnippetStartPosition += source.length();

    }

    source.append(buildTypeBody(buffer, typeDeclaration.bodyDeclarations()));

    return source;

  }

  private StringBuffer buildCompilationUnit(StringBuffer buffer,

      CompilationUnit compilationUnit) {

    StringBuffer source = new StringBuffer();

    PackageDeclaration packageDeclaration = compilationUnit.getPackage();

    if (packageDeclaration != null) {

      source.append("package "); //$NON-NLS-1$

      source.append(getQualifiedIdentifier(packageDeclaration.getName()));

      source.append(";\n"); //$NON-NLS-1$

    }

    for (Iterator<ImportDeclaration> iterator = compilationUnit.imports().iterator(); iterator

        .hasNext();) {

      ImportDeclaration importDeclaration = iterator

          .next();

      source.append("import "); //$NON-NLS-1$

      if (importDeclaration.isStatic()) {

        source.append("static "); //$NON-NLS-1$

      }

      source.append(getQualifiedIdentifier(importDeclaration.getName()));

      if (importDeclaration.isOnDemand()) {

        source.append(".*"); //$NON-NLS-1$

      }

      source.append(";\n"); //$NON-NLS-1$

    }

    fSnippetStartPosition += source.length();

    source.append(buffer);

    for (Iterator<TypeDeclaration> iterator = compilationUnit.types().iterator(); iterator

        .hasNext();) {

      AbstractTypeDeclaration typeDeclaration = iterator.next();

      if (Flags.isPublic(typeDeclaration.getModifiers())) {

        fCompilationUnitName = typeDeclaration.getName()

            .getIdentifier();

      }

      if (!fLastTypeName

          .equals(typeDeclaration.getName().getIdentifier())) {

        if (typeDeclaration instanceof TypeDeclaration) {

          source.append(buildTypeDeclaration(null,

              (TypeDeclaration) typeDeclaration));

        } else if (typeDeclaration instanceof EnumDeclaration) {

          source.append(buildEnumDeclaration(null,

              (EnumDeclaration) typeDeclaration));

        }

      }

    }

    if (fCompilationUnitName == null) {

      // If no public class was found, the compilation unit

      // name doesn't matter.

      fCompilationUnitName = "Eval"; //$NON-NLS-1$

    }

    return source;

  }

  /**

   * Returns a method name that will be unique in the generated source. The

   * generated name is baseName plus as many '_' characters as necessary to

   * not duplicate an existing method name.

   *

   * @param methodName

   *            the method name to look for

   * @param bodyDeclarations

   *            the listing of {@link BodyDeclaration}s to search through

   * @return the unique method name

   */

  private String getUniqueMethodName(String methodName, List<BodyDeclaration> bodyDeclarations) {

    Iterator<BodyDeclaration> iter = bodyDeclarations.iterator();

    BodyDeclaration bodyDeclaration;

    MethodDeclaration method;

    String foundName;

    while (iter.hasNext()) {

      bodyDeclaration = iter.next();

      if (bodyDeclaration instanceof MethodDeclaration) {

        method = (MethodDeclaration) bodyDeclaration;

        foundName = method.getName().getIdentifier();

        if (foundName.startsWith(methodName)) {

          methodName = foundName + '_';

        }

      }

    }

    return methodName;

  }

  /**

   * Returns a field name that will be unique in the generated source. The

   * generated name is baseName plus as many '_' characters as necessary to

   * not duplicate an existing method name.

   *

   * @param fieldName

   *            the name of the field to look for

   * @param bodyDeclarations

   *            the list of {@link BodyDeclaration}s to search through

   * @return the unique field name

   */

  private String getUniqueFieldName(String fieldName, List<BodyDeclaration> bodyDeclarations) {

    Iterator<BodyDeclaration> iter = bodyDeclarations.iterator();

    BodyDeclaration bodyDeclaration;

    FieldDeclaration fieldDeclaration;

    String foundName;

    while (iter.hasNext()) {

      bodyDeclaration = iter.next();

      if (bodyDeclaration instanceof FieldDeclaration) {

        fieldDeclaration = (FieldDeclaration) bodyDeclaration;

        for (Iterator<VariableDeclarationFragment> iterator = fieldDeclaration.fragments()

            .iterator(); iterator.hasNext();) {

          foundName = iterator.next()

              .getName().getIdentifier();

          if (foundName.startsWith(fieldName)) {

            fieldName = foundName + '_';

          }

        }

      }

    }

    return fieldName;

  }

  private String getQualifiedIdentifier(Name name) {

    String typeName = ""; //$NON-NLS-1$

    while (name.isQualifiedName()) {

      QualifiedName qualifiedName = (QualifiedName) name;

      typeName = "." + qualifiedName.getName().getIdentifier() + typeName; //$NON-NLS-1$

      name = qualifiedName.getQualifier();

    }

    if (name.isSimpleName()) {

      typeName = ((SimpleName) name).getIdentifier() + typeName;

    } else {

      return null;

    }

    return typeName;

  }

  public String getTypeName(Type type) {

    if (type.isSimpleType()) {

      String name = getQualifiedIdentifier(((SimpleType) type).getName());

      if (!isSourceLevelGreaterOrEqual(1, 5)

          && fTypeParameters.contains(name)) {

        return "Object"; //$NON-NLS-1$

      }

      return name;

    } else if (type.isArrayType()) {

      return getTypeName(((ArrayType) type).getComponentType()) + "[]"; //$NON-NLS-1$

    } else if (type.isPrimitiveType()) {

      return ((PrimitiveType) type).getPrimitiveTypeCode().toString();

    } else if (type.isQualifiedType()) {

      QualifiedType qualifiedType = (QualifiedType) type;

      return getTypeName(qualifiedType.getQualifier()) + '.'

          + qualifiedType.getName().getIdentifier();

    } else if (type.isParameterizedType()) {

      ParameterizedType parameterizedType = (ParameterizedType) type;

      StringBuffer buff = new StringBuffer(

          getTypeName(parameterizedType.getType()));

      Iterator<Type> iter = parameterizedType.typeArguments().iterator();

      if (iter.hasNext() && isSourceLevelGreaterOrEqual(1, 5)) {

        buff.append('<');

        buff.append(getTypeName(iter.next()));

        while (iter.hasNext()) {

          buff.append(',');

          buff.append(getTypeName(iter.next()));

        }

        buff.append('>');

      }

      return buff.toString();

    } else if (type.isWildcardType()) {

      WildcardType wildcardType = (WildcardType) type;

      StringBuffer buff = new StringBuffer("?"); //$NON-NLS-1$

      Type bound = wildcardType.getBound();

      if (bound != null) {

        buff.append(wildcardType.isUpperBound() ? " extends " : " super "); //$NON-NLS-1$ //$NON-NLS-2$

        buff.append(getTypeName(bound));

      }

      return buff.toString();

    }

    return null;

  }

  public String getReturnExpression(Type type) {

    if (type.isSimpleType() || type.isArrayType() || type.isQualifiedType()

        || type.isWildcardType() || type.isParameterizedType()) {

      return "return null;"; //$NON-NLS-1$

    } else if (type.isPrimitiveType()) {

      String typeName = ((PrimitiveType) type).getPrimitiveTypeCode()

          .toString();

      char char0 = typeName.charAt(0);

      if (char0 == 'v') {

        return ""; //$NON-NLS-1$

      }

      char char1 = typeName.charAt(1);

      if (char0 == 'b' && char1 == 'o') {

        return "return false;"; //$NON-NLS-1$

      }

      return "return 0;"; //$NON-NLS-1$

    }

    return null;

  }

  // ----------------------

  /**

   * @see ASTVisitor#endVisit(ClassInstanceCreation)

   */

  @Override

  public void endVisit(ClassInstanceCreation node) {

    if (hasError()) {

      return;

    }

    AnonymousClassDeclaration anonymousClassDeclaration = node

        .getAnonymousClassDeclaration();

    if (anonymousClassDeclaration != null) {

      if (!rightTypeFound() && isRightType(node)) {

        setRightTypeFound(true);

        fSource = buildRunMethod(anonymousClassDeclaration

            .bodyDeclarations());

        fEvaluateNextEndTypeDeclaration = true;

      }

      if (rightTypeFound()) {

        List<BodyDeclaration> bodyDeclarations = anonymousClassDeclaration

            .bodyDeclarations();

        StringBuffer source = buildTypeBody(fSource, bodyDeclarations);

        ASTNode parent = node.getParent();

        while (!(parent instanceof MethodDeclaration

            || parent instanceof FieldDeclaration || parent instanceof Initializer)

            && parent != null) {

          parent = parent.getParent();

        }

        fSource = new StringBuffer();

        if (parent instanceof Initializer) {

          createAnonymousEvalMethod(true, bodyDeclarations,

              getTypeName(node.getType()), source);

        } else if (parent instanceof MethodDeclaration) {

          MethodDeclaration enclosingMethodDeclaration = (MethodDeclaration) parent;

          createAnonymousEvalMethod(

              Flags.isStatic(enclosingMethodDeclaration

                  .getModifiers()), bodyDeclarations,

              getTypeName(node.getType()), source);

        } else if (parent instanceof FieldDeclaration) {

          FieldDeclaration enclosingFieldDeclaration = (FieldDeclaration) parent;

          if (Flags

              .isStatic(enclosingFieldDeclaration.getModifiers())) {

            fSource.append("static "); //$NON-NLS-1$

          }

          Type type = getParentType(enclosingFieldDeclaration

              .getType());

          fSource.append(getQualifiedIdentifier(((SimpleType) type)

              .getName()));

          fSource.append(' ');

          fSource.append(getUniqueFieldName(EVAL_FIELD_NAME,

              bodyDeclarations));

          fSource.append(" = new "); //$NON-NLS-1$

          fSource.append(getTypeName(node.getType()));

          fSource.append("()"); //$NON-NLS-1$

          fSnippetStartPosition += fSource.length();

          fSource.append(source);

          fSource.append(";\n"); //$NON-NLS-1$

        }

        fLastTypeName = ""; //$NON-NLS-1$

      }

    }

  }

  /**

   * Create a <code>void ____eval()</code> method considering the given

   * {@link BodyDeclaration}s, type name and existing body source when an

   * anonymous {@link ClassInstanceCreation} is visited. <br>

   * <br>

   * This method adds the new <code>___eval</code> method source to the root

   * {@link #fSource} variable directly

   *

   * @param isstatic

   *            if the keyword <code>static</code> should be added to the

   *            method source

   * @param bodydecls

   *            the existing listing of {@link BodyDeclaration}s to consider

   *            when creating the <code>___eval</code> method name

   * @param typename

   *            the raw type name of the type to instantiate in the

   *            <code>___eval</code> method

   * @param body

   *            the existing body of source to append to the remainder of the

   *            new method

   * @since 3.7

   */

  void createAnonymousEvalMethod(boolean isstatic, List<BodyDeclaration> bodydecls,

      String typename, StringBuffer body) {

    if (isstatic) {

      fSource.append("static "); //$NON-NLS-1$

    }

    fSource.append("void "); //$NON-NLS-1$

    fSource.append(getUniqueMethodName(EVAL_METHOD_NAME, bodydecls));

    fSource.append("() {\n"); //$NON-NLS-1$

    fSource.append("new "); //$NON-NLS-1$

    fSource.append(typename);

    fSource.append("()"); //$NON-NLS-1$

    fSnippetStartPosition += fSource.length();

    fSource.append(body);

    fSource.append(";}\n"); //$NON-NLS-1$

  }

  /**

   * Recursively finds the parent {@link Type} from the given type, in the

   * cases where the type is an {@link ArrayType} or a

   * {@link ParameterizedType}

   *

   * @param type

   *            the {@link Type}

   * @return the parent {@link Type}

   */

  private Type getParentType(Type type) {

    if (type instanceof ArrayType) {

      return getParentType(((ArrayType) type).getComponentType());

    }

    if (type instanceof ParameterizedType) {

      return getParentType(((ParameterizedType) type).getType());

    }

    return type;

  }

  /**

   * @see ASTVisitor#endVisit(CompilationUnit)

   */

  @Override

  public void endVisit(CompilationUnit node) {

    if (hasError()) {

      return;

    }

    if (!rightTypeFound()) { // if the right type hasn't been found

      fSource = null;

      return;

    }

    fSource = buildCompilationUnit(fSource, node);

  }

  /*

   * (non-Javadoc)

   *

   * @see

   * org.eclipse.jdt.core.dom.ASTVisitor#endVisit(org.eclipse.jdt.core.dom

   * .EnumDeclaration)

   */

  @Override

  public void endVisit(EnumDeclaration node) {