/*******************************************************************************
* 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
*
* Contributors:
* xored software, Inc. - initial API and Implementation (Andrei Sobolev)
* xored software, Inc. - RubyDocumentation display improvements (Alex Panchenko <alex@xored.com>)
*******************************************************************************/
package org.eclipse.dltk.ruby.internal.core.codeassist;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.dltk.ast.ASTNode;
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.references.ConstantReference;
import org.eclipse.dltk.ast.references.VariableReference;
import org.eclipse.dltk.codeassist.ScriptSelectionEngine;
import org.eclipse.dltk.compiler.env.IModuleSource;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IField;
import org.eclipse.dltk.core.IMember;
import org.eclipse.dltk.core.IMethod;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ISourceRange;
import org.eclipse.dltk.core.IType;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.ScriptModelUtil;
import org.eclipse.dltk.core.mixin.IMixinElement;
import org.eclipse.dltk.core.search.IDLTKSearchConstants;
import org.eclipse.dltk.core.search.IDLTKSearchScope;
import org.eclipse.dltk.core.search.SearchEngine;
import org.eclipse.dltk.core.search.SearchMatch;
import org.eclipse.dltk.core.search.SearchParticipant;
import org.eclipse.dltk.core.search.SearchPattern;
import org.eclipse.dltk.core.search.SearchRequestor;
import org.eclipse.dltk.core.search.TypeNameMatch;
import org.eclipse.dltk.core.search.TypeNameMatchRequestor;
import org.eclipse.dltk.ruby.ast.RubyAssignment;
import org.eclipse.dltk.ruby.ast.RubyColonExpression;
import org.eclipse.dltk.ruby.ast.RubyForStatement2;
import org.eclipse.dltk.ruby.ast.RubyMethodArgument;
import org.eclipse.dltk.ruby.ast.RubySuperExpression;
import org.eclipse.dltk.ruby.core.RubyPlugin;
import org.eclipse.dltk.ruby.core.model.FakeField;
import org.eclipse.dltk.ruby.core.utils.RubySyntaxUtils;
import org.eclipse.dltk.ruby.internal.parser.mixin.RubyMixinClass;
import org.eclipse.dltk.ruby.internal.parser.mixin.RubyMixinElementInfo;
import org.eclipse.dltk.ruby.internal.parser.mixin.RubyMixinMethod;
import org.eclipse.dltk.ruby.internal.parser.mixin.RubyMixinModel;
import org.eclipse.dltk.ruby.internal.parsers.jruby.ASTUtils;
import org.eclipse.dltk.ruby.typeinference.RubyClassType;
import org.eclipse.dltk.ruby.typeinference.RubyModelUtils;
import org.eclipse.dltk.ruby.typeinference.RubyTypeInferencingUtils;
import org.eclipse.dltk.ruby.typeinference.evaluators.ColonExpressionEvaluator;
import org.eclipse.dltk.ruby.typeinference.evaluators.ConstantReferenceEvaluator;
import org.eclipse.dltk.ruby.typeinference.goals.NonTypeConstantTypeGoal;
import org.eclipse.dltk.ti.BasicContext;
import org.eclipse.dltk.ti.DLTKTypeInferenceEngine;
import org.eclipse.dltk.ti.GoalState;
import org.eclipse.dltk.ti.goals.AbstractTypeGoal;
import org.eclipse.dltk.ti.goals.ExpressionTypeGoal;
import org.eclipse.dltk.ti.goals.IGoal;
import org.eclipse.dltk.ti.types.IEvaluatedType;
public class RubySelectionEngine extends ScriptSelectionEngine {
public static final boolean DEBUG = DLTKCore.DEBUG_SELECTION;
protected int actualSelectionStart;
protected int actualSelectionEnd;
private Set<IModelElement> selectionElements = new HashSet<IModelElement>();
private RubySelectionParser parser = new RubySelectionParser();
private ISourceModule sourceModule;
private ASTNode[] wayToNode;
private DLTKTypeInferenceEngine inferencer;
private TypeDeclaration getEnclosingType(ASTNode node) {
return ASTUtils.getEnclosingType(wayToNode, node, true);
}
private CallExpression getEnclosingCallNode(ASTNode node) {
return ASTUtils.getEnclosingCallNode(wayToNode, node, true);
}
public RubySelectionEngine() {
inferencer = new DLTKTypeInferenceEngine();
}
private RubyMixinModel mixinModel;
@Override
public IModelElement[] select(IModuleSource sourceUnit,
int selectionSourceStart, int selectionSourceEnd) {
sourceModule = (ISourceModule) sourceUnit.getModelElement();
mixinModel = RubyMixinModel
.getInstance(sourceModule.getScriptProject());
String source = sourceUnit.getSourceContents();
if (DEBUG) {
System.out.print("SELECTION IN "); //$NON-NLS-1$
System.out.print(sourceUnit.getFileName());
System.out.print(" FROM "); //$NON-NLS-1$
System.out.print(selectionSourceStart);
System.out.print(" TO "); //$NON-NLS-1$
System.out.println(selectionSourceEnd);
System.out.println("SELECTION - Source :"); //$NON-NLS-1$
System.out.println(source);
}
if (!checkSelection(source, selectionSourceStart, selectionSourceEnd)) {
return new IModelElement[0];
}
actualSelectionEnd--; // inclusion fix
if (DEBUG) {
System.out.print("SELECTION - Checked : \""); //$NON-NLS-1$
System.out.print(source.substring(actualSelectionStart,
actualSelectionEnd + 1));
System.out.println('"');
}
try {
ModuleDeclaration parsedUnit = this.parser.parse(sourceUnit);
if (parsedUnit != null) {
if (DEBUG) {
System.out.println("SELECTION - AST :"); //$NON-NLS-1$
System.out.println(parsedUnit.toString());
}
ASTNode node = ASTUtils.findMinimalNode(parsedUnit,
actualSelectionStart, actualSelectionEnd);
if (node == null)
return new IModelElement[0];
this.wayToNode = ASTUtils.restoreWayToNode(parsedUnit, node);
if (node instanceof TypeDeclaration) {
selectionOnTypeDeclaration(parsedUnit,
(TypeDeclaration) node);
} else if (node instanceof MethodDeclaration) {
selectionOnMethodDeclaration(parsedUnit,
(MethodDeclaration) node);
} else if (node instanceof ConstantReference
|| node instanceof RubyColonExpression) {
selectTypes(parsedUnit, node);
} else if (node instanceof VariableReference) {
selectionOnVariable(parsedUnit, (VariableReference) node);
} else if (node instanceof RubyMethodArgument) {
selectOnMethodArgument(parsedUnit,
(RubyMethodArgument) node);
} else if (node instanceof RubySuperExpression) {
selectOnSuper(parsedUnit, (RubySuperExpression) node);
} else {
CallExpression parentCall = this.getEnclosingCallNode(node);
if (parentCall != null) {
selectOnMethod(parsedUnit, parentCall);
} else { // parentCall == null
}
}
}
} catch (IndexOutOfBoundsException e) { // work-around internal failure
RubyPlugin.log(e);
}
return selectionElements.toArray(new IModelElement[selectionElements.size()]);
}
private void selectOnSuper(ModuleDeclaration parsedUnit,
RubySuperExpression superExpr) {
RubyClassType selfClass = RubyTypeInferencingUtils.determineSelfClass(
mixinModel, sourceModule, parsedUnit, superExpr.sourceStart());
MethodDeclaration enclosingMethod = ASTUtils.getEnclosingMethod(
wayToNode, superExpr, false);
if (enclosingMethod != null) {
String name = enclosingMethod.getName();
RubyMixinClass rubyClass = mixinModel.createRubyClass(selfClass);
RubyMixinClass superclass = rubyClass.getSuperclass();
RubyMixinMethod method = superclass.getMethod(name);
if (method != null) {
IMethod[] sourceMethods = method.getSourceMethods();
addArrayToCollection(sourceMethods, selectionElements);
}
}
}
private void selectOnColonExpression(ModuleDeclaration parsedUnit,
RubyColonExpression node) {
BasicContext basicContext = new BasicContext(sourceModule, parsedUnit);
ColonExpressionEvaluator evaluator = new ColonExpressionEvaluator(
new ExpressionTypeGoal(basicContext, node));
IGoal[] init = evaluator.init();
if (init == null || init.length == 0) {
// should never be here
// System.err.println("Why did ColonExpressionEvaluator evaluated so
// fast?");
} else {
IEvaluatedType leftType = inferencer.evaluateType(
(AbstractTypeGoal) init[0], -1);
IGoal[] goals = evaluator.subGoalDone(init[0], leftType,
GoalState.DONE);
if (goals == null || goals.length == 0) { // good, we have
// type-constant
Object evaluatedType = evaluator.produceResult();
if (evaluatedType instanceof RubyClassType) {
RubyMixinClass mixinClass = mixinModel
.createRubyClass((RubyClassType) evaluatedType);
if (mixinClass != null)
addArrayToCollection(mixinClass.getSourceTypes(),
selectionElements);
}
} else {
if (goals[0] instanceof NonTypeConstantTypeGoal) {
processNonTypeConstant((NonTypeConstantTypeGoal) (goals[0]));
}
}
}
}
/**
* Uses goal info for selection on non-type goal
*
* @param ngoal
*/
private void processNonTypeConstant(NonTypeConstantTypeGoal ngoal) {
IMixinElement element = ngoal.getElement();
if (element != null) {
Object[] eObjects = element.getAllObjects();
for (int i = 0; i < eObjects.length; i++) {
if (eObjects[i] instanceof RubyMixinElementInfo) {
RubyMixinElementInfo info = (RubyMixinElementInfo) eObjects[i];
Object obj = info.getObject();
if (obj instanceof IModelElement) {
this.selectionElements.add((IModelElement) obj);
}
}
}
}
}
private void selectOnConstant(ModuleDeclaration parsedUnit,
ConstantReference node) {
BasicContext basicContext = new BasicContext(sourceModule, parsedUnit);
ConstantReferenceEvaluator evaluator = new ConstantReferenceEvaluator(
new ExpressionTypeGoal(basicContext, node));
IGoal[] init = evaluator.init();
if (init == null || init.length == 0) {
Object evaluatedType = evaluator.produceResult();
if (evaluatedType instanceof RubyClassType) {
RubyMixinClass mixinClass = mixinModel
.createRubyClass((RubyClassType) evaluatedType);
if (mixinClass != null)
addArrayToCollection(mixinClass.getSourceTypes(),
selectionElements);
}
} else if (init[0] instanceof NonTypeConstantTypeGoal) {
// it'a non-type constant
processNonTypeConstant((NonTypeConstantTypeGoal) init[0]);
}
}
/**
* Checks, whether giver selection is correct selection, or can be expanded
* to correct selection region. As result will set
* this.actualSelection(Start|End) properly. In case of incorrect selection,
* will return false.
*
* @param source
* @param start
* @param end
* @return
*/
protected boolean checkSelection(String source, int start, int end) {
if (start > end) {
int x = start;
start = end;
end = x;
}
if (start + 1 == end) {
ISourceRange range = RubySyntaxUtils.getEnclosingName(source, end);
if (range != null) {
this.actualSelectionStart = range.getOffset();
this.actualSelectionEnd = this.actualSelectionStart
+ range.getLength();
// return true;
}
ISourceRange range2 = RubySyntaxUtils.insideMethodOperator(source,
end);
if (range != null
&& (range2 == null || range2.getLength() < range
.getLength()))
return true;
if (range2 != null) {
this.actualSelectionStart = range2.getOffset();
this.actualSelectionEnd = this.actualSelectionStart
+ range2.getLength();
return true;
}
} else {
if (start >= 0 && end < source.length()) {
String str = source.substring(start, end + 1);
if (RubySyntaxUtils.isRubyName(str)) {
this.actualSelectionStart = start;
this.actualSelectionEnd = end + 1;
return true;
}
}
}
return false;
}
private void selectTypes(ModuleDeclaration parsedUnit, ASTNode node) {
if (node instanceof ConstantReference) {
selectOnConstant(parsedUnit, (ConstantReference) node);
} else if (node instanceof RubyColonExpression) {
selectOnColonExpression(parsedUnit, (RubyColonExpression) node);
}
if (selectionElements.isEmpty()) {
TypeNameMatchRequestor requestor = new TypeNameMatchRequestor() {
@Override
public void acceptTypeNameMatch(TypeNameMatch match) {
selectionElements.add(match.getType());
}
};
String unqualifiedName = null;
if (node instanceof RubyColonExpression) {
RubyColonExpression expr = (RubyColonExpression) node;
unqualifiedName = expr.getName();
} else if (node instanceof ConstantReference) {
ConstantReference expr = (ConstantReference) node;
unqualifiedName = expr.getName();
}
if (unqualifiedName != null) {
ScriptModelUtil.searchTypeDeclarations(sourceModule
.getScriptProject(), unqualifiedName, requestor);
}
}
}
private void selectOnMethodArgument(ModuleDeclaration parsedUnit,
RubyMethodArgument arg) {
selectionElements.add(createLocalVariable(arg.getName(), arg
.sourceStart(), arg.sourceEnd()));
}
private void selectionOnVariable(ModuleDeclaration parsedUnit,
VariableReference e) {
String name = e.getName();
if (name.startsWith("@")) { //$NON-NLS-1$
IField[] fields = RubyModelUtils.findFields(mixinModel,
sourceModule, parsedUnit, name, e.sourceStart());
addArrayToCollection(fields, selectionElements);
} else {
/*
* local vars (legacy, saved for speed reasons: we don't need to use
* mixin model for local vars)
*/
ASTNode parentScope = null;
for (int i = wayToNode.length; --i >= 0;) {
final ASTNode node = wayToNode[i];
if (node instanceof MethodDeclaration
|| node instanceof TypeDeclaration
|| node instanceof ModuleDeclaration
|| node instanceof RubyForStatement2) {
parentScope = node;
break;
}
}
if (parentScope != null) {
RubyAssignment[] assignments = RubyTypeInferencingUtils
.findLocalVariableAssignments(parentScope, e, name);
if (assignments.length > 0) {
final ASTNode left = assignments[0].getLeft();
selectionElements.add(createLocalVariable(name, left
.sourceStart(), left.sourceEnd()));
} else {
selectionElements.add(createLocalVariable(name, e
.sourceStart(), e.sourceEnd()));
}
}
}
}
private IField createLocalVariable(String name, int nameStart, int nameEnd) {
return new FakeField(sourceModule, name, nameStart, nameEnd - nameStart);
}
private IType[] getSourceTypesForClass(ModuleDeclaration parsedUnit,
ASTNode statement) {
ExpressionTypeGoal typeGoal = new ExpressionTypeGoal(new BasicContext(
sourceModule, parsedUnit), statement);
IEvaluatedType evaluatedType = this.inferencer.evaluateType(typeGoal,
5000);
if (evaluatedType instanceof RubyClassType) {
RubyMixinClass mixinClass = mixinModel
.createRubyClass((RubyClassType) evaluatedType);
if (mixinClass != null)
return mixinClass.getSourceTypes();
}
return new IType[0];
}
private void selectionOnTypeDeclaration(ModuleDeclaration parsedUnit,
TypeDeclaration typeDeclaration) {
// if (typeDeclaration instanceof RubyClassDeclaration) {
// RubyClassDeclaration rcd = (RubyClassDeclaration) typeDeclaration;
// IType[] types = getSourceTypesForClass(parsedUnit, rcd
// .getClassName());
// selectionElements.addAll(Arrays.asList(types));
// }
IModelElement elementAt = null;
try {
elementAt = sourceModule
.getElementAt(typeDeclaration.sourceStart() + 1);
} catch (ModelException e) {
RubyPlugin.log(e);
}
if (elementAt != null)
selectionElements.add(elementAt);
}
private void selectionOnMethodDeclaration(ModuleDeclaration parsedUnit,
MethodDeclaration methodDeclaration) {
IModelElement elementAt = null;
try {
elementAt = sourceModule.getElementAt(methodDeclaration
.sourceStart() + 1);
} catch (ModelException e) {
RubyPlugin.log(e);
}
if (elementAt != null)
selectionElements.add(elementAt);
}
private void selectOnMethod(ModuleDeclaration parsedUnit,
CallExpression parentCall) {
String methodName = parentCall.getName();
ASTNode receiver = parentCall.getReceiver();
final List<IModelElement> availableMethods = new ArrayList<IModelElement>();
if (receiver == null) {
IEvaluatedType type = RubyTypeInferencingUtils.determineSelfClass(
mixinModel, sourceModule, parsedUnit, parentCall
.sourceStart());
if ((type != null) && "Object".equals(type.getTypeName())) { //$NON-NLS-1$
ExpressionTypeGoal goal = new ExpressionTypeGoal(
new BasicContext(sourceModule, parsedUnit), parsedUnit);
IEvaluatedType type2 = inferencer.evaluateType(goal, 2000);
if (type2 != null) {
type = type2;
}
}
IMethod[] m = RubyModelUtils.searchClassMethodsExact(mixinModel,
sourceModule, parsedUnit, type, methodName);
addArrayToCollection(m, availableMethods);
} else {
ExpressionTypeGoal goal = new ExpressionTypeGoal(new BasicContext(
sourceModule, parsedUnit), receiver);
IEvaluatedType type = inferencer.evaluateType(goal, 5000);
IMethod[] m = RubyModelUtils.searchClassMethodsExact(mixinModel,
sourceModule, parsedUnit, type, methodName);
addArrayToCollection(m, availableMethods);
if (receiver instanceof VariableReference) {
IMethod[] availableMethods2 = RubyModelUtils
.getSingletonMethods(mixinModel,
(VariableReference) receiver, parsedUnit,
sourceModule, methodName);
addArrayToCollection(availableMethods2, availableMethods);
}
}
if (availableMethods.isEmpty()) {
searchMethodDeclarations(sourceModule.getScriptProject(),
methodName, availableMethods);
}
if (!availableMethods.isEmpty()) {
for (int i = 0, size = availableMethods.size(); i < size; ++i) {
final IMethod m = (IMethod) availableMethods.get(i);
if (methodName.equals(methodName)) {
selectionElements.add(m);
}
}
}
}
private static void searchMethodDeclarations(IScriptProject project,
String methodName, final List<IModelElement> availableMethods) {
final SearchRequestor requestor = new SearchRequestor() {
@Override
public void acceptSearchMatch(SearchMatch match)
throws CoreException {
IModelElement modelElement = (IModelElement) match.getElement();
ISourceModule sm = (ISourceModule) modelElement
.getAncestor(IModelElement.SOURCE_MODULE);
IModelElement elementAt = sm.getElementAt(match.getOffset());
if (elementAt.getElementType() == IModelElement.METHOD) {
availableMethods.add(elementAt);
}
}
};
final IDLTKSearchScope scope = SearchEngine.createSearchScope(project);
try {
final SearchEngine engine = new SearchEngine();
final SearchPattern pattern = SearchPattern.createPattern(
methodName, IDLTKSearchConstants.METHOD,
IDLTKSearchConstants.DECLARATIONS,
SearchPattern.R_EXACT_MATCH
| SearchPattern.R_CASE_SENSITIVE,
DLTKLanguageManager.getLanguageToolkit(project));
final SearchParticipant[] participants = new SearchParticipant[] { SearchEngine
.getDefaultSearchParticipant() };
engine.search(pattern, participants, scope, requestor, null);
} catch (CoreException e) {
RubyPlugin.log(e);
}
}
/**
* @param src
* @param dest
*/
private static void addArrayToCollection(IMember[] src, Collection<IModelElement> dest) {
if (src != null) {
for (int i = 0, size = src.length; i < size; ++i) {
dest.add(src[i]);
}
}
}
}