/*******************************************************************************
* 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.core.codeassist;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.dltk.ast.ASTNode;
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.CallArgumentsList;
import org.eclipse.dltk.ast.expressions.CallExpression;
import org.eclipse.dltk.ast.expressions.NumericLiteral;
import org.eclipse.dltk.ast.expressions.StringLiteral;
import org.eclipse.dltk.ast.parser.ISourceParser;
import org.eclipse.dltk.ast.references.ConstantReference;
import org.eclipse.dltk.ast.references.SimpleReference;
import org.eclipse.dltk.codeassist.ScriptCompletionEngine;
import org.eclipse.dltk.compiler.env.IModuleSource;
import org.eclipse.dltk.compiler.util.Util;
import org.eclipse.dltk.core.CompletionProposal;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.Flags;
import org.eclipse.dltk.core.IField;
import org.eclipse.dltk.core.IMethod;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.IType;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.mixin.IMixinElement;
import org.eclipse.dltk.core.mixin.MixinModel;
import org.eclipse.dltk.evaluation.types.AmbiguousType;
import org.eclipse.dltk.evaluation.types.IClassType;
import org.eclipse.dltk.internal.core.util.WeakHashSet;
import org.eclipse.dltk.ruby.ast.RubyBlock;
import org.eclipse.dltk.ruby.ast.RubyColonExpression;
import org.eclipse.dltk.ruby.ast.RubyDAssgnExpression;
import org.eclipse.dltk.ruby.ast.RubyDVarExpression;
import org.eclipse.dltk.ruby.ast.RubySelfReference;
import org.eclipse.dltk.ruby.core.RubyNature;
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.IMixinSearchRequestor;
import org.eclipse.dltk.ruby.internal.parser.mixin.IRubyMixinElement;
import org.eclipse.dltk.ruby.internal.parser.mixin.PrefixNoCaseMixinSearchPattern;
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.parser.mixin.RubyMixinUtils;
import org.eclipse.dltk.ruby.internal.parser.mixin.RubyMixinVariable;
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.ti.BasicContext;
import org.eclipse.dltk.ti.DLTKTypeInferenceEngine;
import org.eclipse.dltk.ti.goals.ExpressionTypeGoal;
import org.eclipse.dltk.ti.types.IEvaluatedType;
public class RubyCompletionEngine extends ScriptCompletionEngine {
/**
* Type inferencer timeout
*/
private static final int TI_TIMEOUT = 2000;
private final static int RELEVANCE_FREE_SPACE = 100000;
/**
* Relevance for keywords. Should be used only for keywords - the distinct
* value is required to sort templates (their relevance is much lower by
* default) before the matching keywords - see
* ScriptCompletionProposalComputer#updateTemplateProposalRelevance()
*/
private final static int RELEVANCE_KEYWORD = 1000000;
private final static int RELEVANCE_TYPE = 2000000;
private final static int RELEVANCE_METHODS = 10000000;
private final static int RELEVANCE_VARIABLES = 100000000;
private final static String[] globalVars = { "$DEBUG", "$$", "$-i", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"$deferr", "$/", "$'", "$stdout", "$-l", "$-I", "$.", "$KCODE", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$
"$binding", "$-w", "$FILENAME", "$defout", "$,", "$`", "$-F", "$*", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$
"$LOADED_FEATURES", "$stdin", "$-p", "$:", "$\\", "$=", "$!", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
"$-v", "$>", "$&", "$;", "$SAFE", "$PROGRAM_NAME", "$\"", "$-d", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$
"$?", "$-0", "$+", "$@", "$-a", "$VERBOSE", "$stderr", "$~", "$0", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$ //$NON-NLS-9$
"$LOAD_PATH", "$<", "$_", "$-K" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
private DLTKTypeInferenceEngine inferencer;
private ISourceParser parser = null;
private RubyMixinModel mixinModel;
private HashSet<String> completedNames = new HashSet<String>();
private WeakHashSet intresting = new WeakHashSet();
private ASTNode completionNode;
private ISourceModule currentModule;
public RubyCompletionEngine() {
this.inferencer = new DLTKTypeInferenceEngine();
this.parser = DLTKLanguageManager.getSourceParser(RubyNature.NATURE_ID);
}
@Override
protected int getEndOfEmptyToken() {
return 0;
}
@Override
protected String processMethodName(IMethod method, String token) {
return null;
}
@Override
protected String processTypeName(IType method, String token) {
return null;
}
private boolean afterColons(String content, int position) {
if (position < 2)
return false;
if (content.charAt(position - 1) == ':'
&& content.charAt(position - 2) == ':')
return true;
return false;
}
private boolean afterDollar(String content, int position) {
if (position < 1)
return false;
if (content.charAt(position - 1) == '$')
return true;
return false;
}
private boolean afterAt(String content, int position) {
if (position < 1)
return false;
if (content.charAt(position - 1) == '@')
return true;
return false;
}
private boolean afterAt2(String content, int position) {
if (position < 2)
return false;
if (content.charAt(position - 1) == '@'
&& content.charAt(position - 2) == '@')
return true;
return false;
}
private boolean afterDot(String content, int position) {
return position >= 1 && content.charAt(position - 1) == '.';
}
private String getWordStarting(String content, int position, int maxLen) {
if (position <= 0 || position > content.length())
return Util.EMPTY_STRING;
final int original = position;
while (position > 0
&& maxLen > 0
&& ((content.charAt(position - 1) == ':')
|| (content.charAt(position - 1) == '\'')
|| (content.charAt(position - 1) == '"') || RubySyntaxUtils
.isLessStrictIdentifierCharacter(content
.charAt(position - 1)))) {
--position;
--maxLen;
}
return content.substring(position, original);
}
@Override
public void complete(IModuleSource module, int position, int i) {
this.currentModule = (ISourceModule) module;
this.mixinModel = RubyMixinModel.getInstance(currentModule
.getScriptProject());
completedNames.clear();
this.actualCompletionPosition = position;
this.requestor.beginReporting();
try {
final String content = module.getSourceContents();
String wordStarting = getWordStarting(content, position, 10);
if (wordStarting.length() != 0) {
this.setSourceRange(position - wordStarting.length(), position);
String[] keywords = RubyKeyword.findByPrefix(wordStarting);
for (int j = 0; j < keywords.length; j++) {
reportKeyword(keywords[j]);
}
}
ModuleDeclaration moduleDeclaration = (ModuleDeclaration) parser
.parse(module, null);
if (afterDollar(content, position)) {
completeGlobalVar(moduleDeclaration, "$", position); //$NON-NLS-1$
} else if (afterAt2(content, position)) {
completeSimpleRef(moduleDeclaration, "@@", position); //$NON-NLS-1$
} else if (afterAt(content, position)) {
completeSimpleRef(moduleDeclaration, "@", position); //$NON-NLS-1$
} else if (afterColons(content, position)) {
ASTNode node = ASTUtils.findMaximalNodeEndingAt(
moduleDeclaration, position - 2);
this.setSourceRange(position, position);
if (node != null) {
BasicContext basicContext = new BasicContext(currentModule,
moduleDeclaration);
ExpressionTypeGoal goal = new ExpressionTypeGoal(
basicContext, node);
IEvaluatedType type = inferencer.evaluateType(goal,
TI_TIMEOUT * 3 / 2);
reportSubElements(type, Util.EMPTY_STRING);
} else {
completeConstant(moduleDeclaration, Util.EMPTY_STRING,
position, true);
}
} else {
ASTNode minimalNode = ASTUtils.findMinimalNode(
moduleDeclaration, position, position);
if (minimalNode != null) {
if (minimalNode instanceof CallExpression) {
CallExpression callExp = (CallExpression) minimalNode;
if ((position > 0)
&& (content.charAt(position - 1) == ' ')) {
minimalNode = callExp.getArgs();
}
}
this.completionNode = minimalNode;
if (minimalNode instanceof CallExpression) {
completeCall(moduleDeclaration,
(CallExpression) minimalNode, position);
} else if (minimalNode instanceof CallArgumentsList) {
completeSimpleRef(moduleDeclaration, wordStarting,
position);
IEvaluatedType self = RubyTypeInferencingUtils
.determineSelfClass(mixinModel, currentModule,
moduleDeclaration, position);
if ((self != null)
&& "Object".equals(self.getTypeName())) { //$NON-NLS-1$
ExpressionTypeGoal goal = new ExpressionTypeGoal(
new BasicContext(currentModule,
moduleDeclaration), minimalNode);
IEvaluatedType self2 = inferencer.evaluateType(
goal, TI_TIMEOUT);
if (self2 != null) {
self = self2;
}
}
completeClassMethods(moduleDeclaration, self,
Util.EMPTY_STRING, true);
} else if (minimalNode instanceof ConstantReference) {
completeConstant(moduleDeclaration,
(ConstantReference) minimalNode, position);
} else if (minimalNode instanceof RubyColonExpression) {
completeColonExpression(moduleDeclaration,
(RubyColonExpression) minimalNode, position);
} else if (minimalNode instanceof SimpleReference) {
completeSimpleRef(moduleDeclaration, wordStarting,
position);
} else if (minimalNode instanceof RubyDVarExpression) {
if (afterDot(content, position)) {
completeClassMethods(moduleDeclaration,
minimalNode, wordStarting);
} else {
completeSimpleRef(moduleDeclaration, wordStarting,
position);
}
} else if (minimalNode instanceof MethodDeclaration
|| minimalNode instanceof TypeDeclaration
|| minimalNode instanceof StringLiteral) {
completeSimpleRef(moduleDeclaration, wordStarting,
position);
IEvaluatedType self = RubyTypeInferencingUtils
.determineSelfClass(mixinModel, currentModule,
moduleDeclaration, position);
if ((self != null)
&& "Object".equals(self.getTypeName())) { //$NON-NLS-1$
ExpressionTypeGoal goal = new ExpressionTypeGoal(
new BasicContext(currentModule,
moduleDeclaration), minimalNode);
IEvaluatedType self2 = inferencer.evaluateType(
goal, TI_TIMEOUT);
if (self2 != null) {
self = self2;
}
}
completeClassMethods(moduleDeclaration, self,
wordStarting, true);
} else if (minimalNode instanceof ModuleDeclaration) {
ExpressionTypeGoal goal = new ExpressionTypeGoal(
new BasicContext(currentModule,
moduleDeclaration), minimalNode);
IEvaluatedType self = inferencer.evaluateType(goal,
TI_TIMEOUT);
completeClassMethods(moduleDeclaration, self,
wordStarting, true);
} else if (minimalNode instanceof NumericLiteral
&& position > 0
&& position == minimalNode.sourceEnd()
&& position > minimalNode.sourceStart()
&& content.charAt(position - 1) == '.') {
setSourceRange(position, position);
completeClassMethods(moduleDeclaration, minimalNode,
Util.EMPTY_STRING);
} else { // worst case
completeSimpleRef(moduleDeclaration, wordStarting,
position);
if (wordStarting.length() == 0
&& !requestor.isContextInformationMode()) {
if (!afterContentAndSpace(moduleDeclaration,
content, position)) {
reportCurrentElements(moduleDeclaration,
position);
}
}
}
}
}
} finally {
this.requestor.endReporting();
}
}
/**
* @param content
* @param position
* @return
*/
private boolean afterContentAndSpace(ModuleDeclaration moduleDeclaration,
String content, int position) {
while (position > 0) {
final char c = content.charAt(position - 1);
if (c == ' ' || c == '\t') {
--position;
} else {
break;
}
}
if (position > 0
&& RubySyntaxUtils.isIdentifierCharacter(content
.charAt(position - 1))) {
ASTNode node = ASTUtils.findMinimalNode(moduleDeclaration,
position, position);
if (node instanceof CallExpression) {
int begin = position;
while (begin > 0 && content.charAt(begin - 1) != '\r'
&& content.charAt(begin - 1) != '\n') {
--begin;
}
ASTNode[] way = ASTUtils.restoreWayToNode(moduleDeclaration,
node);
for (int i = way.length - 1; --i >= 0;) {
if (way[i] instanceof CallExpression) {
// if multiple method calls in the same line
return way[i].sourceStart() >= begin;
}
}
return false;
}
return true;
}
return false;
}
private void reportCurrentElements(ModuleDeclaration moduleDeclaration,
int position) {
setSourceRange(position, position);
completeSimpleRef(moduleDeclaration, Util.EMPTY_STRING, position);
IClassType self = RubyTypeInferencingUtils.determineSelfClass(
mixinModel, currentModule, moduleDeclaration, position);
if (self == null) {
return;
}
completeClassMethods(moduleDeclaration, self, Util.EMPTY_STRING, true);
if ("Object".equals(self.getTypeName())) { //$NON-NLS-1$
try {
final IModelElement[] children = currentModule.getChildren();
if (children != null) {
for (int i = 0; i < children.length; ++i) {
IModelElement element = children[i];
if (element instanceof IField) {
reportField((IField) element, RELEVANCE_FREE_SPACE);
} else if (element instanceof IMethod) {
IMethod method = (IMethod) element;
if ((method.getFlags() & Modifiers.AccStatic) == 0) {
reportMethod(method, RELEVANCE_FREE_SPACE);
}
} else if (element instanceof IType) {
if (!element.getElementName().trim().startsWith(
"<<")) //$NON-NLS-1$
reportType((IType) element,
RELEVANCE_FREE_SPACE);
}
}
}
} catch (ModelException e) {
RubyPlugin.log(e);
}
}
}
private class CompletionMixinMethodRequestor implements
IMixinSearchRequestor {
private String lastParent = null;
private boolean lastParentIsSuperClass = true;
private final List<RubyMixinMethod> group = new ArrayList<RubyMixinMethod>();
private final RubyMixinClass klass;
private final boolean isSelf;
public CompletionMixinMethodRequestor(RubyMixinClass klass,
boolean isSelf) {
this.klass = klass;
this.isSelf = isSelf;
}
/**
* Tests that the specified key identifies superclass of the
* {@link #klass} or the same class.
*
* @param key
* @return
*/
private boolean isSuperClass(String key) {
if (!RubyMixinUtils.isObjectOrKernel(key)) {
if (key.equals(klass.getKey())) {
return true;
}
RubyMixinClass superclass = klass.getSuperclass();
while (superclass != null) {
final String superClassKey = superclass.getKey();
if (RubyMixinUtils.isObjectOrKernel(superClassKey)) {
break;
}
if (key.equals(superClassKey)) {
return true;
}
superclass = superclass.getSuperclass();
}
}
return false;
}
@Override
public void acceptResult(IRubyMixinElement element) {
if (element instanceof RubyMixinMethod) {
final RubyMixinMethod method = (RubyMixinMethod) element;
final RubyMixinClass selfClass = method.getSelfType();
if (lastParent == null
|| !lastParent.equals(selfClass.getKey())) {
if (lastParent != null) {
this.flush();
}
lastParent = selfClass.getKey();
lastParentIsSuperClass = isSuperClass(lastParent);
}
int flags = 0;
final IMethod[] methods = method.getSourceMethods();
for (int cnt = 0, max = methods.length; cnt < max; cnt++) {
final IMethod m = methods[cnt];
if (m != null) {
try {
flags |= m.getFlags();
} catch (ModelException mxcn) {
// ignore
}
}
}
final boolean shouldAdd = Flags.isPublic(flags)
|| lastParentIsSuperClass && Flags.isProtected(flags)
|| Flags.isPrivate(flags) && isSelf
|| RubyMixinUtils.isKernel(selfClass.getKey());
if (shouldAdd)
group.add(method);
}
}
public void flush() {
if (group.size() > 0) {
RubyMixinMethod[] mixinMethods = group.toArray(new RubyMixinMethod[group.size()]);
final List<IMethod> methods = RubyModelUtils.getAllSourceMethods(
mixinMethods, klass);
int skew = 0;
if (klass.getKey().equals(lastParent)) {
skew = 2;
} else if (lastParentIsSuperClass) {
// TODO calculate the distance in the hierarchy
skew = 1;
}
for (int j = 0, size = methods.size(); j < size; j++) {
reportMethod(methods.get(j), RELEVANCE_METHODS + skew);
}
group.clear();
}
}
}
private void completeClassMethods(ModuleDeclaration moduleDeclaration,
RubyMixinClass rubyClass, String prefix, boolean isSelf) {
CompletionMixinMethodRequestor mixinSearchRequestor = new CompletionMixinMethodRequestor(
rubyClass, isSelf);
rubyClass.findMethods(new PrefixNoCaseMixinSearchPattern(prefix),
mixinSearchRequestor);
mixinSearchRequestor.flush();
}
private void completeClassMethods(ModuleDeclaration moduleDeclaration,
IEvaluatedType type, String prefix, boolean isSelf) {
if (type instanceof RubyClassType) {
RubyClassType rubyClassType = (RubyClassType) type;
RubyMixinClass rubyClass = mixinModel
.createRubyClass(rubyClassType);
if (rubyClass != null) {
completeClassMethods(moduleDeclaration, rubyClass, prefix,
isSelf);
}
} else if (type instanceof AmbiguousType) {
AmbiguousType type2 = (AmbiguousType) type;
IEvaluatedType[] possibleTypes = type2.getPossibleTypes();
for (int i = 0; i < possibleTypes.length; i++) {
completeClassMethods(moduleDeclaration, possibleTypes[i],
prefix, isSelf);
}
}
}
private void completeClassMethods(ModuleDeclaration moduleDeclaration,
ASTNode receiver, String pattern) {
ExpressionTypeGoal goal = new ExpressionTypeGoal(new BasicContext(
currentModule, moduleDeclaration), receiver);
IEvaluatedType type = inferencer.evaluateType(goal, TI_TIMEOUT);
completeClassMethods(moduleDeclaration, type, pattern,
receiver instanceof RubySelfReference);
}
private void completeGlobalVar(ModuleDeclaration moduleDeclaration,
String prefix, int position) {
this.setSourceRange(position - (prefix != null ? prefix.length() : 0),
position);
IMixinElement[] elements = mixinModel.getRawModel().find(
(prefix != null ? prefix : Util.EMPTY_STRING) + "*", new NullProgressMonitor()); //$NON-NLS-1$
// String[] findKeys = RubyMixinModel.getRawInstance().findKeys(
// prefix + "*");
for (int i = 0; i < elements.length; i++) {
IRubyMixinElement rubyElement = mixinModel
.createRubyElement(elements[i]);
if (rubyElement instanceof RubyMixinVariable) {
RubyMixinVariable variable = (RubyMixinVariable) rubyElement;
IField[] sourceFields = variable.getSourceFields();
for (int j = 0; j < sourceFields.length; j++) {
if (sourceFields[j] != null) {
reportField(sourceFields[j], RELEVANCE_VARIABLES);
break;
}
}
}
}
for (int i = 0; i < globalVars.length; i++) {
if (prefix == null || globalVars[i].startsWith(prefix))
reportField(new FakeField(currentModule, globalVars[i], 0, 0),
RELEVANCE_VARIABLES);
}
}
private void completeSimpleRef(ModuleDeclaration moduleDeclaration,
String prefix, int position) {
this.setSourceRange(position - prefix.length(), position);
ASTNode[] wayToNode = ASTUtils.restoreWayToNode(moduleDeclaration,
this.completionNode);
for (int i = wayToNode.length - 1; i > 0; i--) {
if (wayToNode[i] instanceof RubyBlock) {
RubyBlock rubyBlock = (RubyBlock) wayToNode[i];
Set<ASTNode> vars = rubyBlock.getVars();
for (Iterator<ASTNode> iterator = vars.iterator(); iterator.hasNext();) {
ASTNode n = iterator.next();
if (n instanceof RubyDAssgnExpression) {
RubyDAssgnExpression rd = (RubyDAssgnExpression) n;
if (rd.getName().startsWith(prefix)) {
reportField(new FakeField(currentModule, rd
.getName(), 0, 0), RELEVANCE_VARIABLES);
}
}
}
}
}
if (prefix.startsWith("$")) { // globals //$NON-NLS-1$
completeGlobalVar(moduleDeclaration, prefix, position);
} else { // class & instance & locals
IField[] fields = RubyModelUtils.findFields(mixinModel,
currentModule, moduleDeclaration, prefix, position);
for (int i = 0; i < fields.length; i++) {
reportField(fields[i], RELEVANCE_VARIABLES);
}
}
}
private void reportSubElements(IEvaluatedType type, String prefix) {
if (!(type instanceof RubyClassType)) {
return;
}
RubyClassType rubyClassType = (RubyClassType) type;
IMixinElement mixinElement = mixinModel.getRawModel().get(
rubyClassType.getModelKey());
if (mixinElement == null) {
return;
}
List<IType> types = new ArrayList<IType>();
List<IMethod> methods = new ArrayList<IMethod>();
List<IField> fields = new ArrayList<IField>();
IMixinElement[] children = mixinElement.getChildren();
for (int i = 0; i < children.length; i++) {
Object[] infos = children[i].getAllObjects();
for (int j = 0; j < infos.length; j++) {
RubyMixinElementInfo obj = (RubyMixinElementInfo) infos[j];
if (obj.getObject() == null)
continue;
if (obj.getKind() == RubyMixinElementInfo.K_CLASS
|| obj.getKind() == RubyMixinElementInfo.K_MODULE) {
IType type2 = (IType) obj.getObject();
if (type2 != null
&& (prefix == null || type2.getElementName()
.startsWith(prefix))) {
types.add(type2);
}
} else if (obj.getKind() == RubyMixinElementInfo.K_METHOD) {
IMethod method2 = (IMethod) obj.getObject();
if (method2 != null
&& (prefix == null || method2.getElementName()
.startsWith(prefix))) {
methods.add(method2);
}
}
if (obj.getKind() == RubyMixinElementInfo.K_VARIABLE) {
IField fff = (IField) obj.getObject();
if (fff != null
&& (prefix == null || fff.getElementName()
.startsWith(prefix))) {
fields.add(fff);
}
}
break;
}
}
for (Iterator<IField> iterator = fields.iterator(); iterator.hasNext();) {
IField t = iterator.next();
reportField(t, RELEVANCE_VARIABLES);
}
for (Iterator<IType> iterator = types.iterator(); iterator.hasNext();) {
IType t = iterator.next();
reportType(t, RELEVANCE_TYPE);
}
for (Iterator<IMethod> iterator = methods.iterator(); iterator.hasNext();) {
IMethod t = iterator.next();
reportMethod(t, RELEVANCE_METHODS);
}
}
private void completeColonExpression(ModuleDeclaration moduleDeclaration,
RubyColonExpression node, int position) {
String content;
try {
content = currentModule.getSource();
} catch (ModelException e) {
return;
}
int pos = (node.getLeft() != null) ? (node.getLeft().sourceEnd() + 2)
: (node.sourceStart());
String starting = null;
try {
starting = content.substring(pos, position).trim();
} catch (IndexOutOfBoundsException e) {
e.printStackTrace();
return;
}
if (starting.startsWith("::")) { //$NON-NLS-1$
this.setSourceRange(position - starting.length() + 2, position);
completeConstant(moduleDeclaration, starting.substring(2),
position, true);
return;
}
this.setSourceRange(position - starting.length(), position);
ExpressionTypeGoal goal = new ExpressionTypeGoal(new BasicContext(
currentModule, moduleDeclaration), node.getLeft());
IEvaluatedType type = inferencer.evaluateType(goal, TI_TIMEOUT * 3 / 2);
reportSubElements(type, starting);
}
private void completeConstant(ModuleDeclaration moduleDeclaration,
String prefix, int position, boolean topLevelOnly) {
IType[] types = RubyTypeInferencingUtils.getAllTypes(currentModule,
prefix);
Arrays.sort(types, new ProjectTypeComparator(currentModule));
final Set<String> names = new HashSet<String>();
for (int i = 0; i < types.length; i++) {
final String elementName = types[i].getElementName();
if (names.add(elementName)) {
reportType(types[i], RELEVANCE_TYPE);
}
}
if (!topLevelOnly) {
IMixinElement[] modelStaticScopes = RubyTypeInferencingUtils
.getModelStaticScopes(mixinModel.getRawModel(),
moduleDeclaration, position);
for (int i = modelStaticScopes.length - 1; i >= 0; i--) {
IMixinElement scope = modelStaticScopes[i];
if (scope == null)
continue;
reportSubElements(new RubyClassType(scope.getKey()), prefix);
}
}
if (prefix != null && prefix.length() > 0) {
String varkey = "Object" + MixinModel.SEPARATOR + prefix; //$NON-NLS-1$
String[] keys2 = mixinModel.getRawModel().findKeys(varkey + "*", new NullProgressMonitor()); //$NON-NLS-1$
for (int i = 0; i < keys2.length; i++) {
IRubyMixinElement element = mixinModel
.createRubyElement(keys2[i]);
if (element instanceof RubyMixinVariable) {
RubyMixinVariable variable = (RubyMixinVariable) element;
IField[] sourceFields = variable.getSourceFields();
for (int j = 0; j < sourceFields.length; j++) {
if (sourceFields[j] != null) {
reportField(sourceFields[j], RELEVANCE_VARIABLES);
break;
}
}
}
}
}
}
private void completeConstant(ModuleDeclaration moduleDeclaration,
ConstantReference node, int position) {
String content;
try {
content = currentModule.getSource();
} catch (ModelException e) {
return;
}
String prefix = content.substring(node.sourceStart(), position);
this.setSourceRange(position - prefix.length(), position);
completeConstant(moduleDeclaration, prefix, position, false);
}
private void completeCall(ModuleDeclaration moduleDeclaration,
CallExpression node, int position) {
ASTNode receiver = node.getReceiver();
String content;
try {
content = currentModule.getSource();
} catch (ModelException e) {
return;
}
int pos = (receiver != null) ? (receiver.sourceEnd() == node
.sourceStart()) ? receiver.sourceStart() : (receiver
.sourceEnd() + 1) : (node.sourceStart());
for (int t = 0; t < 2; t++) { // correct not more 2 chars
if (pos < position
&& !RubySyntaxUtils.isStrictIdentifierCharacter(content
.charAt(pos))) // for (...).name and Foo::name
// calls
pos++;
}
String starting = content.substring(pos, position).trim();
if ((receiver == null) || (receiver.sourceEnd() == node.sourceStart())) {
completeSimpleRef(moduleDeclaration, starting, position);
completeConstant(moduleDeclaration, starting, position, false);
}
this.setSourceRange(position - starting.length(), position);
if (starting.startsWith("__")) { //$NON-NLS-1$
String[] keywords = RubyKeyword.findByPrefix("__"); //$NON-NLS-1$
for (int j = 0; j < keywords.length; j++) {
reportKeyword(keywords[j]);
}
}
if ((receiver != null) && (receiver.sourceEnd() != node.sourceStart())) {
completeClassMethods(moduleDeclaration, receiver, starting);
} else {
IEvaluatedType self = RubyTypeInferencingUtils.determineSelfClass(
mixinModel, currentModule, moduleDeclaration, position);
if ((self != null) && "Object".equals(self.getTypeName())) { //$NON-NLS-1$
ASTNode minNode = node;
ASTNode[] wayToNode = ASTUtils.restoreWayToNode(
moduleDeclaration, node);
for (int cnt = (wayToNode.length - 2); cnt >= 0; cnt--) {
if ((wayToNode[cnt] instanceof TypeDeclaration)
|| (wayToNode[cnt] instanceof ModuleDeclaration)) {
minNode = wayToNode[cnt];
break;
}
}
ExpressionTypeGoal goal = new ExpressionTypeGoal(
new BasicContext(currentModule, moduleDeclaration),
minNode);
IEvaluatedType self2 = inferencer
.evaluateType(goal, TI_TIMEOUT);
if (self2 != null) {
self = self2;
}
}
completeClassMethods(moduleDeclaration, self, starting, true);
}
}
private void reportMethod(IMethod method, int rel) {
this.intresting.add(method);
String elementName = method.getElementName();
if (completedNames.contains(elementName)) {
return;
}
completedNames.add(elementName);
if (elementName.indexOf('.') != -1) {
elementName = elementName.substring(elementName.indexOf('.') + 1);
}
String name = elementName;
String compl = name;
// accept result
noProposal = false;
if (!requestor.isIgnored(CompletionProposal.METHOD_REF)) {
CompletionProposal proposal = createProposal(
CompletionProposal.METHOD_REF, actualCompletionPosition);
String[] params = null;
try {
params = method.getParameterNames();
} catch (ModelException e) {
// ssanders: Ignore
}
if (params != null && params.length > 0) {
proposal.setParameterNames(params);
}
proposal.setModelElement(method);
proposal.setName(name);
proposal.setCompletion(compl);
try {
proposal.setFlags(method.getFlags());
} catch (ModelException e) {
// ssanders: Ignore
}
proposal.setReplaceRange(this.startPosition - this.offset,
this.endPosition - this.offset);
proposal.setRelevance(rel);
this.requestor.accept(proposal);
if (DEBUG) {
this.printDebug(proposal);
}
}
}
private void reportType(IType type, int rel) {
this.intresting.add(type);
String elementName = type.getElementName();
if (completedNames.contains(elementName)) {
return;
}
completedNames.add(elementName);
String name = elementName;
if (name.length() == 0)
return;
// accept result
noProposal = false;
if (!requestor.isIgnored(CompletionProposal.TYPE_REF)) {
CompletionProposal proposal = createProposal(
CompletionProposal.TYPE_REF, actualCompletionPosition);
proposal.setModelElement(type);
proposal.setName(name);
proposal.setCompletion(elementName);
// proposal.setFlags(Flags.AccDefault);
try {
proposal.setFlags(type.getFlags());
} catch (ModelException e) {
}
proposal.setReplaceRange(this.startPosition - this.offset,
this.endPosition - this.offset);
proposal.setRelevance(rel);
this.requestor.accept(proposal);
if (DEBUG) {
this.printDebug(proposal);
}
}
}
private void reportField(IField field, int rel) {
this.intresting.add(field);
String elementName = field.getElementName();
if (completedNames.contains(elementName)) {
return;
}
completedNames.add(elementName);
String name = elementName;
if (name.length() == 0)
return;
// accept result
noProposal = false;
if (!requestor.isIgnored(CompletionProposal.FIELD_REF)) {
CompletionProposal proposal = createProposal(
CompletionProposal.FIELD_REF, actualCompletionPosition);
proposal.setModelElement(field);
proposal.setName(name);
proposal.setCompletion(elementName);
// proposal.setFlags(Flags.AccDefault);
proposal.setReplaceRange(this.startPosition - this.offset,
this.endPosition - this.offset);
proposal.setRelevance(rel);
this.requestor.accept(proposal);
if (DEBUG) {
this.printDebug(proposal);
}
}
}
private void reportKeyword(String name) {
// accept result
noProposal = false;
if (!requestor.isIgnored(CompletionProposal.KEYWORD)) {
CompletionProposal proposal = createProposal(
CompletionProposal.KEYWORD, actualCompletionPosition);
proposal.setName(name);
proposal.setCompletion(name);
// proposal.setFlags(Flags.AccDefault);
proposal.setReplaceRange(this.startPosition - this.offset,
this.endPosition - this.offset);
proposal.setRelevance(RELEVANCE_KEYWORD);
this.requestor.accept(proposal);
if (DEBUG) {
this.printDebug(proposal);
}
}
}
}