public boolean visit(CallExpression call) throws Exception {
FieldDeclaration constantDecl = ASTUtils.getConstantDeclaration(call);
if (constantDecl != null) {
// In case we are entering a nested element
if (!declarations.empty() && declarations.peek() instanceof MethodDeclaration) {
deferredDeclarations.add(constantDecl);
return visitGeneral(call);
}
visit((FieldDeclaration) constantDecl);
} else {
int argsCount = 0;
CallArgumentsList args = call.getArgs();
if (args != null && args.getChilds() != null) {
argsCount = args.getChilds().size();
}
modifyReference(
call,
new ReferenceInfo(
IModelElement.METHOD,
call.sourceStart(),
call.sourceEnd() - call.sourceStart(),
call.getName(),
Integer.toString(argsCount),
null));
}
return visitGeneral(call);
}
public boolean visit(CallExpression call) throws Exception {
final FieldDeclaration constantDecl = ASTUtils.getConstantDeclaration(call);
if (constantDecl != null) {
// In case we are entering a nested element
if (!declarations.empty() && declarations.peek() instanceof MethodDeclaration) {
deferredDeclarations.add(constantDecl);
return false;
}
visit(constantDecl);
} else {
int argsCount = 0;
final CallArgumentsList args = call.getArgs();
if (args != null && args.getChilds() != null) {
argsCount = args.getChilds().size();
}
fRequestor.acceptMethodReference(
call.getName(),
argsCount,
call.getCallName().sourceStart(),
call.getCallName().sourceEnd());
}
return true;
}
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);
}
}
}
}
@Override
public boolean visitGeneral(ASTNode node) throws Exception {
if (!ACTIVE) {
return true;
}
if (node instanceof RubyRegexpExpression || node instanceof RubyDRegexpExpression) {
handleRegexp(node);
} else if (node instanceof RubySymbolReference) {
requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_SYMBOL);
} else if (node instanceof VariableReference) {
handleVariableReference((VariableReference) node);
} else if (node instanceof RubyDVarExpression) {
requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_LOCAL_VARIABLE);
} else if (node instanceof RubyDAssgnExpression) {
ASTNode var = ((RubyDAssgnExpression) node).getLeft();
requestor.addPosition(var.sourceStart(), var.sourceEnd(), HL_LOCAL_VARIABLE);
} else if (node instanceof StringLiteral) {
if (isStringLiteralNeeded(node)) {
requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_STRING);
}
} else if (node instanceof NumericLiteral
|| node instanceof FloatNumericLiteral
|| node instanceof BigNumericLiteral) {
requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_NUMBER);
} else if (node instanceof RubyEvaluatableStringExpression) {
handleEvaluatableExpression(node);
} else if (node instanceof CallExpression) {
final CallExpression call = (CallExpression) node;
if (!(RubySyntaxUtils.isRubyOperator(call.getName())
|| call.getReceiver() == null && RubyCodeScanner.isPseudoKeyword(call.getName()))) {
final SimpleReference callName = call.getCallName();
if (callName.sourceStart() >= 0 && callName.sourceEnd() > callName.sourceStart()) {
requestor.addPosition(callName.sourceStart(), callName.sourceEnd(), HL_DEFAULT);
}
}
} else if (node instanceof Declaration) {
final Declaration declaration = (Declaration) node;
requestor.addPosition(declaration.getNameStart(), declaration.getNameEnd(), HL_DEFAULT);
} else if (node instanceof RubyConstantDeclaration) {
final RubyConstantDeclaration declaration = (RubyConstantDeclaration) node;
final SimpleReference name = declaration.getName();
requestor.addPosition(name.sourceStart(), name.sourceEnd(), HL_CONST);
}
stack.push(node);
return true;
}
@Override
protected RubyAstVisitor<?> enterCallExpression(CallExpression node) {
if (name.equalsIgnoreCase(node.getName()) && (needReceiver == (node.getReceiver() != null)))
possibleCalls.add(node);
return this;
}
