plugins/org.eclipse.dltk.ruby.core/src/org/eclipse/dltk/ruby/internal/parsers/jruby/ASTUtils.java

/*******************************************************************************
 * Copyright (c) 2005, 2016 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
 *
 *******************************************************************************/
package org.eclipse.dltk.ruby.internal.parsers.jruby;

import java.util.Stack;

import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.ASTVisitor;
import org.eclipse.dltk.ast.Modifiers;
import org.eclipse.dltk.ast.declarations.MethodDeclaration;
import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
import org.eclipse.dltk.ast.declarations.TypeDeclaration;
import org.eclipse.dltk.ast.expressions.CallExpression;
import org.eclipse.dltk.ast.parser.ISourceParser;
import org.eclipse.dltk.ast.statements.Block;
import org.eclipse.dltk.compiler.env.ModuleSource;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.SourceParserUtil;
import org.eclipse.dltk.ruby.ast.RubyBlock;
import org.eclipse.dltk.ruby.ast.RubyForStatement2;
import org.eclipse.dltk.ruby.ast.RubyIfStatement;
import org.eclipse.dltk.ruby.ast.RubyUnlessStatement;
import org.eclipse.dltk.ruby.ast.RubyUntilStatement;
import org.eclipse.dltk.ruby.ast.RubyWhileStatement;
import org.eclipse.dltk.ruby.core.RubyNature;

public class ASTUtils {

	private ASTUtils() {
		throw new AssertionError("Cannot instantiate utility class"); //$NON-NLS-1$
	}

	public static void setVisibility(MethodDeclaration methodDeclaration,
			int newVisibility) {
		int modifiers = methodDeclaration.getModifiers();
		modifiers = modifiers
				& ~(Modifiers.AccPublic | Modifiers.AccProtected
						| Modifiers.AccPrivate | Modifiers.AccDefault);
		methodDeclaration.setModifiers(modifiers | newVisibility);
	}

	public static ASTNode[] restoreWayToNode(ModuleDeclaration module,
			final ASTNode nde) {
		final Stack<ASTNode> stack = new Stack<ASTNode>();

		ASTVisitor visitor = new ASTVisitor() {
			boolean found = false;

			@Override
			public boolean visitGeneral(ASTNode node) throws Exception {
				if (!found) {
					stack.push(node);
					if (node.locationMatches(nde)) {
						found = true;
					}
				}
				return super.visitGeneral(node);
			}

			@Override
			public void endvisitGeneral(ASTNode node) throws Exception {
				super.endvisitGeneral(node);
				if (!found) {
					stack.pop();
				}
			}
		};

		try {
			module.traverse(visitor);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return stack.toArray(new ASTNode[stack.size()]);
	}

	public static <E extends ASTNode> E getEnclosingElement(Class<E> element,
			ASTNode[] wayToNode, ASTNode node, boolean considerGiven) {
		int pos = -1;
		for (int i = wayToNode.length; --i >= 0;) {
			if (wayToNode[i] == node) {
				pos = i;
				break;
			}
		}
		if (pos != -1) {
			if (!considerGiven)
				pos--;
			for (int i = pos; i >= 0; i--) {
				if (element.isInstance(wayToNode[i])) {
					@SuppressWarnings("unchecked")
					final E result = (E) wayToNode[i];
					return result;
				}
			}
		}

		return null;
	}

	public static TypeDeclaration getEnclosingType(ASTNode[] wayToNode,
			ASTNode node, boolean considerGiven) {
		return getEnclosingElement(TypeDeclaration.class, wayToNode, node,
				considerGiven);
	}

	public static CallExpression getEnclosingCallNode(ASTNode[] wayToNode,
			ASTNode node, boolean considerGiven) {
		return getEnclosingElement(CallExpression.class, wayToNode, node,
				considerGiven);
	}

	public static MethodDeclaration getEnclosingMethod(ASTNode[] wayToNode,
			ASTNode node, boolean considerGiven) {
		return getEnclosingElement(MethodDeclaration.class, wayToNode, node,
				considerGiven);
	}

	/**
	 * Finds minimal ast node, that covers given position
	 * 
	 * @param unit
	 * @param position
	 * @return
	 */
	public static ASTNode findMinimalNode(ModuleDeclaration unit, int start,
			int end) {

		class Visitor extends ASTVisitor {
			ASTNode result = null;
			final int start, end;

			public Visitor(int start, int end) {
				this.start = start;
				this.end = end;
			}

			public ASTNode getResult() {
				return result;
			}

			private int calcLen(ASTNode s) {
				int realStart = s.sourceStart();
				int realEnd = s.sourceEnd();
				if (s instanceof TypeDeclaration) {
					TypeDeclaration declaration = (TypeDeclaration) s;
					realStart = declaration.getNameStart();
					realEnd = declaration.getNameEnd();
				} else if (s instanceof MethodDeclaration) {
					MethodDeclaration declaration = (MethodDeclaration) s;
					realStart = declaration.getNameStart();
					realEnd = declaration.getNameEnd();
				}
				return realEnd - realStart;
			}

			@Override
			public boolean visitGeneral(ASTNode s) throws Exception {
				int realStart = s.sourceStart();
				int realEnd = s.sourceEnd();
				if (s instanceof Block) {
					realStart = realEnd = -42; // never select on blocks
					// ssanders: BEGIN - Modify narrowing logic
				} else if (s instanceof TypeDeclaration) {
					TypeDeclaration declaration = (TypeDeclaration) s;
					realStart = declaration.sourceStart();
					realEnd = declaration.sourceEnd();
				} else if (s instanceof MethodDeclaration) {
					MethodDeclaration declaration = (MethodDeclaration) s;
					realStart = declaration.sourceStart();
					realEnd = declaration.sourceEnd();
				}
				if (realStart <= start && realEnd >= end) {
					if (result != null) {
						if ((s.sourceStart() >= result.sourceStart())
								&& (s.sourceEnd() <= result.sourceEnd()))
							result = s;
					} else {
						result = s;
					}
					// ssanders: END
					if (DLTKCore.DEBUG_SELECTION)
						System.out.println("Found " + s.getClass().getName()); //$NON-NLS-1$
				}
				return true;
			}

		}

		Visitor visitor = new Visitor(start, end);

		try {
			unit.traverse(visitor);
		} catch (Exception e) {
			e.printStackTrace();
		}

		return visitor.getResult();
	}

	/**
	 * Finds minimal ast node, that covers given position
	 * 
	 * @param unit
	 * @param position
	 * @return
	 */
	public static ASTNode findMaximalNodeEndingAt(ModuleDeclaration unit,
			final int boundaryOffset) {

		class Visitor extends ASTVisitor {
			ASTNode result = null;

			public ASTNode getResult() {
				return result;
			}

			@Override
			public boolean visitGeneral(ASTNode s) throws Exception {
				if (s.sourceStart() < 0 || s.sourceEnd() < 0)
					return true;
				int sourceEnd = s.sourceEnd();
				if (Math.abs(sourceEnd - boundaryOffset) <= 0) { // XXX: was
					// ... <= 1
					result = s;
					if (DLTKCore.DEBUG_SELECTION)
						System.out.println("Found " + s.getClass().getName()); //$NON-NLS-1$
				}
				return true;
			}

		}

		Visitor visitor = new Visitor();

		try {
			unit.traverse(visitor);
		} catch (Exception e) {
			e.printStackTrace();
		}

		return visitor.getResult();
	}

	public static ModuleDeclaration getAST(ISourceModule module) {
		return SourceParserUtil.getModuleDeclaration(module);
	}

	public static ModuleDeclaration getAST(char[] cs) {
		ISourceParser sourceParser = DLTKLanguageManager
				.getSourceParser(RubyNature.NATURE_ID);
		ModuleDeclaration declaration = (ModuleDeclaration) sourceParser.parse(
				new ModuleSource("RawSource" //$NON-NLS-1$
						, cs), null);
		return declaration;
	}

	public static boolean isNodeScoping(ASTNode node) {
		return (node instanceof RubyIfStatement
				|| node instanceof RubyForStatement2
				|| node instanceof RubyWhileStatement
				|| node instanceof RubyBlock
				|| node instanceof RubyUntilStatement
				|| node instanceof RubyUnlessStatement
				|| node instanceof TypeDeclaration || node instanceof MethodDeclaration);
	}

}