JavaElementSelections.java

/**
 * Copyright (c) 2010, 2011 Darmstadt University of Technology.
 * 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:
 *    Marcel Bruch - initial API and implementation.
 */
package org.eclipse.recommenders.internal.rcp;

import static com.google.common.base.Optional.*;
import static org.eclipse.recommenders.internal.rcp.l10n.LogMessages.*;
import static org.eclipse.recommenders.rcp.JavaElementSelectionEvent.JavaElementSelectionLocation.*;
import static org.eclipse.recommenders.rcp.utils.JdtUtils.findTypeRoot;
import static org.eclipse.recommenders.utils.Checks.ensureIsNotNull;
import static org.eclipse.recommenders.utils.Logs.log;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.Initializer;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.NodeFinder;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.recommenders.rcp.JavaElementSelectionEvent.JavaElementSelectionLocation;
import org.eclipse.ui.IEditorPart;

import com.google.common.base.Optional;

/**
 * Utility class that resolves a selected java element from editor selection or structured selection.
 */
@SuppressWarnings("restriction")
public final class JavaElementSelections {

    private JavaElementSelections() {
        // Not meant to be instantiated
    }

    @SuppressWarnings("serial")
    private static final Map<StructuralPropertyDescriptor, JavaElementSelectionLocation> MAPPING = new HashMap<StructuralPropertyDescriptor, JavaElementSelectionLocation>() {
        {
            put(CompilationUnit.IMPORTS_PROPERTY, TYPE_DECLARATION);
            put(CompilationUnit.PACKAGE_PROPERTY, TYPE_DECLARATION);
            put(CompilationUnit.TYPES_PROPERTY, TYPE_DECLARATION);

            put(TypeDeclaration.BODY_DECLARATIONS_PROPERTY, TYPE_DECLARATION);
            put(TypeDeclaration.INTERFACE_PROPERTY, TYPE_DECLARATION);
            put(TypeDeclaration.JAVADOC_PROPERTY, TYPE_DECLARATION);
            put(TypeDeclaration.MODIFIERS2_PROPERTY, TYPE_DECLARATION);
            put(TypeDeclaration.NAME_PROPERTY, TYPE_DECLARATION);
            put(TypeDeclaration.SUPERCLASS_TYPE_PROPERTY, TYPE_DECLARATION_EXTENDS);
            put(TypeDeclaration.SUPER_INTERFACE_TYPES_PROPERTY, TYPE_DECLARATION_IMPLEMENTS);
            put(TypeDeclaration.TYPE_PARAMETERS_PROPERTY, UNKNOWN);

            put(MethodDeclaration.BODY_PROPERTY, METHOD_BODY);
            put(MethodDeclaration.CONSTRUCTOR_PROPERTY, METHOD_DECLARATION);
            put(MethodDeclaration.JAVADOC_PROPERTY, METHOD_DECLARATION);
            put(MethodDeclaration.MODIFIERS2_PROPERTY, METHOD_DECLARATION);
            put(MethodDeclaration.NAME_PROPERTY, METHOD_DECLARATION);
            put(MethodDeclaration.PARAMETERS_PROPERTY, METHOD_DECLARATION_PARAMETER);
            put(MethodDeclaration.RETURN_TYPE2_PROPERTY, METHOD_DECLARATION_RETURN);
            put(MethodDeclaration.THROWN_EXCEPTIONS_PROPERTY, METHOD_DECLARATION_THROWS);
            put(MethodDeclaration.TYPE_PARAMETERS_PROPERTY, UNKNOWN);

            put(Initializer.BODY_PROPERTY, METHOD_BODY);
            put(Initializer.MODIFIERS2_PROPERTY, METHOD_DECLARATION);

            put(FieldDeclaration.FRAGMENTS_PROPERTY, FIELD_DECLARATION_INITIALIZER);
            put(VariableDeclarationFragment.NAME_PROPERTY, FIELD_DECLARATION);
            put(FieldDeclaration.TYPE_PROPERTY, FIELD_DECLARATION);
            put(FieldDeclaration.JAVADOC_PROPERTY, FIELD_DECLARATION);
            put(FieldDeclaration.MODIFIERS2_PROPERTY, FIELD_DECLARATION);
        }
    };

    /**
     * Returns the {@link IJavaElement} at the current offset or {@link Optional#absent()} if resolving fails.
     */
    public static Optional<IJavaElement> resolveJavaElementFromEditor(final IEditorPart editor,
            final ITextSelection selection) {
        ensureIsNotNull(editor);
        ensureIsNotNull(selection);
        if (!isValidSelection(selection)) {
            return absent();
        }
        if (editor instanceof JavaEditor) {
            final JavaEditor javaEditor = (JavaEditor) editor;
            return resolveJavaElementFromEditor(javaEditor, selection.getOffset());
        }
        return absent();
    }

    private static boolean isValidSelection(final ITextSelection selection) {
        return selection.getOffset() != -1;
    }

    /**
     * Returns the {@link IJavaElement} at the given offset in the editor.
     *
     */
    public static Optional<IJavaElement> resolveJavaElementFromEditor(final JavaEditor editor, final int offset) {
        ensureIsNotNull(editor);
        ITypeRoot root = findTypeRoot(editor).orNull();
        if (root != null && root.exists()) {
            return resolveJavaElementFromTypeRootInEditor(root, offset);
        }
        return absent();
    }

    /**
     * Returns the {@link IJavaElement} at the given offset. If no {@link IJavaElement} is selected, the innermost
     * enclosing {@link IJavaElement} is returned (e.g., the declaring method or type). If both selection resolutions
     * fail, {@link Optional#absent()} is returned.
     */
    public static Optional<IJavaElement> resolveJavaElementFromTypeRootInEditor(final ITypeRoot root,
            final int offset) {
        ensureIsNotNull(root);
        try {
            if (isInvalidSelection(root, offset)) {
                return absent();
            }

            // try resolve elements at current offset
            final IJavaElement[] elements = root.codeSelect(offset, 0);
            if (elements.length > 0) {
                // return java element under cursor/selection start
                return of(elements[0]);
            } else {
                // XXX MB: decided against selection changes because these
                // frequent changes were too disturbing
                return absent();
                // ignore that for a while:

                // // if no java element has been selected, return the innermost
                // Java element enclosing a given offset.
                // // This might evaluate to null.
                // IJavaElement enclosingElement = root.getElementAt(offset);
                // if (enclosingElement == null) {
                // // selection occurred in empty space somewhere before the
                // type declaration.
                // // return type-root then.
                // enclosingElement = root;
                // }
                // return of(enclosingElement);
            }
        } catch (final Exception e) {
            // actually, these can happen when using snipmatch's in-editor completion.
            // fractions of seconds seem potentially to lead to this exception, thus, we swallow them here.
            if (!isInvalidSelection(root, offset)) {
                log(ERROR_FAILED_TO_RESOLVE_SELECTION, root.getHandleIdentifier(), offset, e);
            }
            return absent();
        }
    }

    private static boolean isInvalidSelection(ITypeRoot root, final int offset) {
        try {
            if (!root.exists()) {
                return true;
            }
            // check whether the type root is part of an package fragment root. If not, it's an invalid selection and
            // all resolutions are likely to fail. Thus, return true (=invalid):
            IJavaElement ancestor = root.getAncestor(IJavaProject.PACKAGE_FRAGMENT_ROOT);
            if (!ancestor.exists()) {
                return true;
            }
            ISourceRange range = root.getSourceRange();
            return range == null || offset < 0 || offset > range.getLength();
        } catch (Exception e) {
            log(ERROR_EXCEPTION_WHILE_CHECKING_OFFSETS, e);
            return false;
        }
    }

    public static JavaElementSelectionLocation resolveSelectionLocationFromAst(final CompilationUnit astRoot,
            final int offset) {
        ensureIsNotNull(astRoot);
        final ASTNode selectedNode = NodeFinder.perform(astRoot, offset, 0);
        if (selectedNode == null) {
            // this *should* never happen but it *can* happen...
            return JavaElementSelectionLocation.UNKNOWN;
        }
        return resolveSelectionLocationFromAstNode(selectedNode);
    }

    public static JavaElementSelectionLocation resolveSelectionLocationFromAstNode(final ASTNode node) {
        if (node == null) {
            return JavaElementSelectionLocation.UNKNOWN;
        }

        // handle a direct selection on a declaration node, i.e., the users
        // select a whitespace as in
        // "public $ void do(){}":
        // TODO Review: create second(?) mapping
        switch (node.getNodeType()) {
        case ASTNode.COMPILATION_UNIT:
        case ASTNode.TYPE_DECLARATION:
            return TYPE_DECLARATION;
        case ASTNode.METHOD_DECLARATION:
        case ASTNode.INITIALIZER:
            return METHOD_DECLARATION;
        case ASTNode.FIELD_DECLARATION:
            return FIELD_DECLARATION;
        default:
        }

        return resolveSelectionLocationFromNonMemberDeclarationNode(node);
    }

    /**
     * some inner node that is not a method, a type or a field declaration node...
     */
    private static JavaElementSelectionLocation resolveSelectionLocationFromNonMemberDeclarationNode(ASTNode node) {
        // deal with special case that no parent exists: for instance, if empty
        // spaces before the package declaration
        // are selected, we translate this to type declaration:
        ASTNode parent = node.getParent();
        if (parent == null) {
            return JavaElementSelectionLocation.TYPE_DECLARATION;
        }
        // we have a child node selected. Let's figure out which location this
        // translates best:
        while (node != null) {
            final StructuralPropertyDescriptor locationInParent = node.getLocationInParent();
            switch (parent.getNodeType()) {
            case ASTNode.VARIABLE_DECLARATION_FRAGMENT:
                if (isVariableNameSelectionInFieldDeclaration(parent, locationInParent)) {
                    return FIELD_DECLARATION;
                }
                break;
            case ASTNode.COMPILATION_UNIT:
            case ASTNode.TYPE_DECLARATION:
            case ASTNode.METHOD_DECLARATION:
            case ASTNode.FIELD_DECLARATION:
            case ASTNode.INITIALIZER:
                return mapLocationInParent(locationInParent);
            default:
                break;
            }
            node = parent;
            parent = parent.getParent();
        }
        return JavaElementSelectionLocation.UNKNOWN;
    }

    private static boolean isVariableNameSelectionInFieldDeclaration(final ASTNode parent,
            final StructuralPropertyDescriptor locationInParent) {
        final ASTNode superparent = parent.getParent();
        return superparent instanceof FieldDeclaration && VariableDeclarationFragment.NAME_PROPERTY == locationInParent;
    }

    private static JavaElementSelectionLocation mapLocationInParent(
            final StructuralPropertyDescriptor locationInParent) {
        final JavaElementSelectionLocation res = MAPPING.get(locationInParent);
        return res != null ? res : JavaElementSelectionLocation.UNKNOWN;
    }

    // TODO Review: rename method
    public static JavaElementSelectionLocation resolveSelectionLocationFromJavaElement(final IJavaElement element) {
        ensureIsNotNull(element);

        switch (element.getElementType()) {
        case IJavaElement.CLASS_FILE:
        case IJavaElement.COMPILATION_UNIT:
        case IJavaElement.PACKAGE_DECLARATION:
        case IJavaElement.IMPORT_DECLARATION:
        case IJavaElement.IMPORT_CONTAINER:
        case IJavaElement.TYPE:
            return TYPE_DECLARATION;
        case IJavaElement.METHOD:
        case IJavaElement.INITIALIZER:
            return METHOD_DECLARATION;
        case IJavaElement.FIELD:
            return FIELD_DECLARATION;
        case IJavaElement.LOCAL_VARIABLE:
            // shouldn't happen in a viewer selection, right?
            return METHOD_BODY;
        case IJavaElement.JAVA_MODEL:
        case IJavaElement.PACKAGE_FRAGMENT:
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        case IJavaElement.ANNOTATION:
        default:
            return JavaElementSelectionLocation.UNKNOWN;
        }
    }
}