ASTProvider.java

/*******************************************************************************
 * Copyright (c) 2000, 2013 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
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.javaeditor;

import org.eclipse.che.jdt.dom.ASTNodes;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.CheASTParser;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.ui.SharedASTProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * @author Evgen Vidolob
 */
public class ASTProvider {
    public static final  int     SHARED_AST_LEVEL              = AST.JLS8;
    public static final  boolean SHARED_AST_STATEMENT_RECOVERY = true;
    public static final  boolean SHARED_BINDING_RECOVERY       = true;
    private static final Logger  LOG                           = LoggerFactory.getLogger(ASTProvider.class);
    private static final String  DEBUG_PREFIX                  = "ASTProvider > "; //$NON-NLS-1$
    private Object fReconcileLock= new Object();
    private CompilationUnit fAST;
    /**
     * Tells whether this class is in debug mode.
     * @since 3.0
     */
    private static final boolean DEBUG                         = false;

    /**
     * Checks whether the given Java element has accessible source.
     *
     * @param je the Java element to test
     * @return <code>true</code> if the element has source
     * @since 3.2
     */
    private static boolean hasSource(ITypeRoot je) {
        if (je == null || !je.exists())
            return false;

        try {
            return je.getBuffer() != null;
        } catch (JavaModelException ex) {
            LOG.error(ex.getMessage(), ex);
        }
        return false;
    }

    /**
     * Returns a string for the given Java element used for debugging.
     *
     * @param javaElement the compilation unit AST
     * @return a string used for debugging
     */
    private String toString(ITypeRoot javaElement) {
        if (javaElement == null)
            return "null"; //$NON-NLS-1$
        else
            return javaElement.getElementName();

    }

    /**
     * Returns a string for the given AST used for debugging.
     *
     * @param ast the compilation unit AST
     * @return a string used for debugging
     */
    private String toString(CompilationUnit ast) {
        if (ast == null)
            return "null"; //$NON-NLS-1$

        List<AbstractTypeDeclaration> types= ast.types();
        if (types != null && types.size() > 0)
            return types.get(0).getName().getIdentifier() + "(" + ast.hashCode() + ")"; //$NON-NLS-1$//$NON-NLS-2$
        else
            return "AST without any type"; //$NON-NLS-1$
    }

    /**
     * Creates a new compilation unit AST.
     *
     * @param input the Java element for which to create the AST
     * @param progressMonitor the progress monitor
     * @return AST
     */
    public static CompilationUnit createAST(final ITypeRoot input, final IProgressMonitor progressMonitor) {
        if (!hasSource(input))
            return null;

        if (progressMonitor != null && progressMonitor.isCanceled())
            return null;

        final CheASTParser parser = CheASTParser.newParser(SHARED_AST_LEVEL);
        parser.setResolveBindings(true);
        parser.setStatementsRecovery(SHARED_AST_STATEMENT_RECOVERY);
        parser.setBindingsRecovery(SHARED_BINDING_RECOVERY);
        parser.setSource(input);

        if (progressMonitor != null && progressMonitor.isCanceled())
            return null;

        final CompilationUnit root[]= new CompilationUnit[1];

        SafeRunner.run(new ISafeRunnable() {
            public void run() {
                try {
                    if (progressMonitor != null && progressMonitor.isCanceled())
                        return;
                    if (DEBUG)
                        System.err.println(getThreadName() + " - " + DEBUG_PREFIX + "creating AST for: " +
                                           input.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$
                    root[0] = (CompilationUnit)parser.createAST(progressMonitor);

                    //mark as unmodifiable
                    ASTNodes.setFlagsToAST(root[0], ASTNode.PROTECT);
                } catch (OperationCanceledException ex) {
                    return;
                }
            }

            public void handleException(Throwable ex) {
                LOG.error(ex.getMessage(), ex);
            }
        });
        return root[0];
    }

    private static String getThreadName() {
        String name= Thread.currentThread().getName();
        if (name != null)
            return name;
        else
            return Thread.currentThread().toString();
    }

    /**
     * Returns a shared compilation unit AST for the given Java element.
     * <p>
     * Clients are not allowed to modify the AST and must synchronize all access to its nodes.
     * </p>
     *
     * @param input the Java element, must not be <code>null</code>
     * @param waitFlag {@link SharedASTProvider#WAIT_YES}, {@link SharedASTProvider#WAIT_NO} or
     *            {@link SharedASTProvider#WAIT_ACTIVE_ONLY}
     * @param progressMonitor the progress monitor or <code>null</code>
     * @return the AST or <code>null</code> if the AST is not available
     */
    public CompilationUnit getAST(final ITypeRoot input, SharedASTProvider.WAIT_FLAG waitFlag, IProgressMonitor progressMonitor) {
        if (input == null || waitFlag == null)
            throw new IllegalArgumentException("input or wait flag are null"); //$NON-NLS-1$

        if (progressMonitor != null && progressMonitor.isCanceled())
            return null;

        boolean isActiveElement;
        synchronized (this) {
            isActiveElement= false; //input.equals(fActiveJavaElement);
            if (isActiveElement) {
                if (fAST != null) {
                    if (DEBUG)
                        System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "returning cached AST:" + toString(fAST) + " for: " + input.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

                    return fAST;
                }
                if (waitFlag == SharedASTProvider.WAIT_NO) {
                    if (DEBUG)
                        System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "returning null (WAIT_NO) for: " + input.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$

                    return null;

                }
            }
        }

        final boolean canReturnNull= waitFlag == SharedASTProvider.WAIT_NO || (waitFlag == SharedASTProvider.WAIT_ACTIVE_ONLY && !(isActiveElement && fAST == null));
        boolean isReconciling= false;
        final ITypeRoot activeElement;
        if (isActiveElement) {
//            synchronized (fReconcileLock) {
//                activeElement= fReconcilingJavaElement;
//                isReconciling= isReconciling(input);
//                if (!isReconciling && !canReturnNull)
//                    aboutToBeReconciled(input);
//            }
        } else
            activeElement= null;

        if (isReconciling) {
            // Wait for AST
//                synchronized (fWaitLock) {
//                    if (isReconciling(input)) {
//                        if (DEBUG)
//                            System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "waiting for AST for: " + input.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$

//                        fWaitLock.wait(30000); // XXX: The 30 seconds timeout is an attempt to at least avoid a deadlock. See https://bugs.eclipse.org/366048#c21
//                    }
//                }

            // Check whether active element is still valid
//                synchronized (this) {
//                    if (activeElement == fActiveJavaElement && fAST != null) {
//                        if (DEBUG)
//                            System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "...got AST: " + toString(fAST) + " for: " + input.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
//
//                        return fAST;
//                    }
//                }
            return getAST(input, waitFlag, progressMonitor);
        } /*else if (canReturnNull)
            return null;*/


        CompilationUnit ast= null;
        try {
            ast= createAST(input, progressMonitor);
            if (progressMonitor != null && progressMonitor.isCanceled()) {
                ast= null;
                if (DEBUG)
                    System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "Ignore created AST for: " + input.getElementName() + " - operation has been cancelled"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            }
        } finally {
            if (isActiveElement) {
                if (fAST != null) {
                    // in the meantime, reconcile created a new AST. Return that one
                    if (DEBUG)
                        System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "Ignore created AST for " + input.getElementName() + " - AST from reconciler is newer"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    reconciled(fAST, input, null);
                    return fAST;
                } else
                    reconciled(ast, input, null);
            }
        }
        return ast;
    }

    /**
     * Update internal structures after reconcile.
     *
     * @param ast the compilation unit AST or <code>null</code> if the working copy was consistent
     *            or reconciliation has been cancelled
     * @param javaElement the Java element for which the AST was built
     * @param progressMonitor the progress monitor
     * @see org.eclipse.jdt.internal.ui.text.java.IJavaReconcilingListener#reconciled(CompilationUnit,
     *      boolean, IProgressMonitor)
     */
    void reconciled(CompilationUnit ast, ITypeRoot javaElement, IProgressMonitor progressMonitor) {
//        if (DEBUG)
//            System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "reconciled: " + toString(javaElement) + ", AST: " + toString(ast)); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
//
//        synchronized (fReconcileLock) {
//            fIsReconciling= false;
//            if (javaElement == null || !javaElement.equals(fReconcilingJavaElement)) {
//
//                if (DEBUG)
//                    System.out.println(getThreadName() + " - " + DEBUG_PREFIX + "  ignoring AST of out-dated editor"); //$NON-NLS-1$ //$NON-NLS-2$
//
//                // Signal - threads might wait for wrong element
//                synchronized (fWaitLock) {
//                    fWaitLock.notifyAll();
//                }
//
//                return;
//            }
//            cache(ast, javaElement);
//        }
    }

}