/**
* Resolve the given source and verify that the arguments in a specific method invocation were
* correctly resolved.
*
* <p>The source is expected to be source for a compilation unit, the first declaration is
* expected to be a class, the first member of which is expected to be a method with a block body,
* and the first statement in the body is expected to be an expression statement whose expression
* is a method invocation. It is the arguments to that method invocation that are tested. The
* method invocation can contain errors.
*
* <p>The arguments were resolved correctly if the number of expressions in the list matches the
* length of the array of indices and if, for each index in the array of indices, the parameter to
* which the argument expression was resolved is the parameter in the invoked method's list of
* parameters at that index. Arguments that should not be resolved to a parameter because of an
* error can be denoted by including a negative index in the array of indices.
*
* @param source the source to be resolved
* @param indices the array of indices used to associate arguments with parameters
* @throws Exception if the source could not be resolved or if the structure of the source is not
* valid
*/
private void validateArgumentResolution(Source source, int... indices) throws Exception {
LibraryElement library = resolve(source);
assertNotNull(library);
ClassElement classElement = library.getDefiningCompilationUnit().getTypes()[0];
ParameterElement[] parameters = classElement.getMethods()[1].getParameters();
CompilationUnit unit = resolveCompilationUnit(source, library);
assertNotNull(unit);
ClassDeclaration classDeclaration = (ClassDeclaration) unit.getDeclarations().get(0);
MethodDeclaration methodDeclaration =
((MethodDeclaration) classDeclaration.getMembers().get(0));
Block block = ((BlockFunctionBody) methodDeclaration.getBody()).getBlock();
ExpressionStatement statement = (ExpressionStatement) block.getStatements().get(0);
MethodInvocation invocation = (MethodInvocation) statement.getExpression();
NodeList<Expression> arguments = invocation.getArgumentList().getArguments();
int argumentCount = arguments.size();
assertEquals(indices.length, argumentCount);
for (int i = 0; i < argumentCount; i++) {
Expression argument = arguments.get(i);
ParameterElement element = argument.getStaticParameterElement();
int index = indices[i];
if (index < 0) {
assertNull(element);
} else {
assertSame(parameters[index], element);
}
}
}
public void test_visitMethodDeclaration_static() {
ElementHolder holder = new ElementHolder();
ElementBuilder builder = new ElementBuilder(holder);
String methodName = "m";
MethodDeclaration methodDeclaration =
methodDeclaration(
Keyword.STATIC,
null,
null,
null,
identifier(methodName),
formalParameterList(),
blockFunctionBody());
methodDeclaration.accept(builder);
MethodElement[] methods = holder.getMethods();
assertLength(1, methods);
MethodElement method = methods[0];
assertNotNull(method);
assertEquals(methodName, method.getName());
assertLength(0, method.getFunctions());
assertLength(0, method.getLabels());
assertLength(0, method.getLocalVariables());
assertLength(0, method.getParameters());
assertFalse(method.isAbstract());
assertTrue(method.isStatic());
assertFalse(method.isSynthetic());
}
public void test_visitMethodDeclaration_setter() {
ElementHolder holder = new ElementHolder();
ElementBuilder builder = new ElementBuilder(holder);
String methodName = "m";
MethodDeclaration methodDeclaration =
methodDeclaration(
null,
null,
Keyword.SET,
null,
identifier(methodName),
formalParameterList(),
blockFunctionBody());
methodDeclaration.accept(builder);
FieldElement[] fields = holder.getFields();
assertLength(1, fields);
FieldElement field = fields[0];
assertNotNull(field);
assertEquals(methodName, field.getName());
assertTrue(field.isSynthetic());
assertNull(field.getGetter());
PropertyAccessorElement setter = field.getSetter();
assertNotNull(setter);
assertTrue(setter.isSetter());
assertFalse(setter.isSynthetic());
assertEquals(methodName, setter.getName());
assertEquals(field, setter.getField());
assertLength(0, setter.getFunctions());
assertLength(0, setter.getLabels());
assertLength(0, setter.getLocalVariables());
assertLength(0, setter.getParameters());
}
public void test_visitMethodDeclaration_withMembers() {
ElementHolder holder = new ElementHolder();
ElementBuilder builder = new ElementBuilder(holder);
String methodName = "m";
String parameterName = "p";
String localVariableName = "v";
String labelName = "l";
String exceptionParameterName = "e";
MethodDeclaration methodDeclaration =
methodDeclaration(
null,
null,
null,
null,
identifier(methodName),
formalParameterList(simpleFormalParameter(parameterName)),
blockFunctionBody(
variableDeclarationStatement(Keyword.VAR, variableDeclaration(localVariableName)),
tryStatement(
block(labeledStatement(list(label(labelName)), returnStatement())),
catchClause(exceptionParameterName))));
methodDeclaration.accept(builder);
MethodElement[] methods = holder.getMethods();
assertLength(1, methods);
MethodElement method = methods[0];
assertNotNull(method);
assertEquals(methodName, method.getName());
assertFalse(method.isAbstract());
assertFalse(method.isStatic());
assertFalse(method.isSynthetic());
VariableElement[] parameters = method.getParameters();
assertLength(1, parameters);
VariableElement parameter = parameters[0];
assertNotNull(parameter);
assertEquals(parameterName, parameter.getName());
VariableElement[] localVariables = method.getLocalVariables();
assertLength(2, localVariables);
VariableElement firstVariable = localVariables[0];
VariableElement secondVariable = localVariables[1];
assertNotNull(firstVariable);
assertNotNull(secondVariable);
assertTrue(
(firstVariable.getName().equals(localVariableName)
&& secondVariable.getName().equals(exceptionParameterName))
|| (firstVariable.getName().equals(exceptionParameterName)
&& secondVariable.getName().equals(localVariableName)));
LabelElement[] labels = method.getLabels();
assertLength(1, labels);
LabelElement label = labels[0];
assertNotNull(label);
assertEquals(labelName, label.getName());
}
@Override
public Void visitMethodDeclaration(MethodDeclaration node) {
visit(node.getExternalKeyword(), " ");
visit(node.getModifierKeyword(), " ");
visit(node.getReturnType(), " ");
visit(node.getPropertyKeyword(), " ");
visit(node.getOperatorKeyword(), " ");
visit(node.getName());
if (!node.isGetter()) {
visit(node.getParameters());
}
visit(" ", node.getBody());
return null;
}
@Override
public Void visitMethodDeclaration(MethodDeclaration node) {
ElementHolder holder = new ElementHolder();
visitChildren(holder, node);
Token property = node.getPropertyKeyword();
if (property == null) {
Identifier methodName = node.getName();
MethodElementImpl element = new MethodElementImpl(methodName);
Token keyword = node.getModifierKeyword();
element.setAbstract(matches(keyword, Keyword.ABSTRACT));
element.setFunctions(holder.getFunctions());
element.setLabels(holder.getLabels());
element.setLocalVariables(holder.getVariables());
element.setParameters(holder.getParameters());
element.setStatic(matches(keyword, Keyword.STATIC));
currentHolder.addMethod(element);
methodName.setElement(element);
} else {
Identifier propertyNameNode = node.getName();
String propertyName = propertyNameNode.getName();
FieldElementImpl field = (FieldElementImpl) currentHolder.getField(propertyName);
if (field == null) {
field = new FieldElementImpl(node.getName().getName());
field.setFinal(true);
field.setStatic(matches(node.getModifierKeyword(), Keyword.STATIC));
currentHolder.addField(field);
}
if (matches(property, Keyword.GET)) {
PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl(propertyNameNode);
getter.setField(field);
getter.setGetter(true);
field.setGetter(getter);
currentHolder.addAccessor(getter);
propertyNameNode.setElement(getter);
} else {
PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl(propertyNameNode);
setter.setField(field);
setter.setSetter(true);
field.setSetter(setter);
field.setFinal(false);
currentHolder.addAccessor(setter);
propertyNameNode.setElement(setter);
}
}
return null;
}
@Override
public R visitMethodDeclaration(MethodDeclaration node) {
node.visitChildren(this);
return null;
}
@Override
public Void visitMethodDeclaration(MethodDeclaration node) {
ElementHolder holder = new ElementHolder();
boolean wasInFunction = inFunction;
inFunction = true;
try {
visitChildren(holder, node);
} finally {
inFunction = wasInFunction;
}
boolean isStatic = node.isStatic();
Token property = node.getPropertyKeyword();
if (property == null) {
SimpleIdentifier methodName = node.getName();
String nameOfMethod = methodName.getName();
if (nameOfMethod.equals(TokenType.MINUS.getLexeme())
&& node.getParameters().getParameters().size() == 0) {
nameOfMethod = "unary-";
}
MethodElementImpl element = new MethodElementImpl(nameOfMethod, methodName.getOffset());
element.setAbstract(node.isAbstract());
element.setFunctions(holder.getFunctions());
element.setLabels(holder.getLabels());
element.setLocalVariables(holder.getLocalVariables());
element.setParameters(holder.getParameters());
element.setStatic(isStatic);
currentHolder.addMethod(element);
methodName.setStaticElement(element);
} else {
SimpleIdentifier propertyNameNode = node.getName();
String propertyName = propertyNameNode.getName();
FieldElementImpl field = (FieldElementImpl) currentHolder.getField(propertyName);
if (field == null) {
field = new FieldElementImpl(node.getName().getName());
field.setFinal(true);
field.setStatic(isStatic);
field.setSynthetic(true);
currentHolder.addField(field);
}
if (matches(property, Keyword.GET)) {
PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl(propertyNameNode);
getter.setFunctions(holder.getFunctions());
getter.setLabels(holder.getLabels());
getter.setLocalVariables(holder.getLocalVariables());
getter.setVariable(field);
getter.setAbstract(
node.getBody() instanceof EmptyFunctionBody && node.getExternalKeyword() == null);
getter.setGetter(true);
getter.setStatic(isStatic);
field.setGetter(getter);
currentHolder.addAccessor(getter);
propertyNameNode.setStaticElement(getter);
} else {
PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl(propertyNameNode);
setter.setFunctions(holder.getFunctions());
setter.setLabels(holder.getLabels());
setter.setLocalVariables(holder.getLocalVariables());
setter.setParameters(holder.getParameters());
setter.setVariable(field);
setter.setAbstract(
node.getBody() instanceof EmptyFunctionBody
&& !matches(node.getExternalKeyword(), Keyword.EXTERNAL));
setter.setSetter(true);
setter.setStatic(isStatic);
field.setSetter(setter);
field.setFinal(false);
currentHolder.addAccessor(setter);
propertyNameNode.setStaticElement(setter);
}
}
holder.validate();
return null;
}