public void test_argumentResolution_setter_static_propertyAccess() throws Exception {
Source source =
addSource(
createSource( //
"main() {",
" A a = new A();",
" a.b.sss = 0;",
"}",
"class A {",
" B b = new B();",
"}",
"class B {",
" set sss(x) {}",
"}"));
LibraryElement library = resolve(source);
CompilationUnitElement unit = library.getDefiningCompilationUnit();
// find "a.b.sss = 0"
AssignmentExpression assignment;
{
FunctionElement mainElement = unit.getFunctions()[0];
FunctionBody mainBody = mainElement.getNode().getFunctionExpression().getBody();
Statement statement = ((BlockFunctionBody) mainBody).getBlock().getStatements().get(1);
ExpressionStatement expressionStatement = (ExpressionStatement) statement;
assignment = (AssignmentExpression) expressionStatement.getExpression();
}
// get parameter
Expression rhs = assignment.getRightHandSide();
ParameterElement parameter = rhs.getStaticParameterElement();
assertNotNull(parameter);
assertEquals("x", parameter.getDisplayName());
// validate
ClassElement classB = unit.getTypes()[1];
PropertyAccessorElement setter = classB.getAccessors()[0];
assertSame(parameter, setter.getParameters()[0]);
}
/**
* 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_visitClassDeclaration_parameterized() {
ElementHolder holder = new ElementHolder();
ElementBuilder builder = new ElementBuilder(holder);
String className = "C";
String firstVariableName = "E";
String secondVariableName = "F";
ClassDeclaration classDeclaration =
classDeclaration(
null,
className,
typeParameterList(firstVariableName, secondVariableName),
null,
null,
null);
classDeclaration.accept(builder);
ClassElement[] types = holder.getTypes();
assertLength(1, types);
ClassElement type = types[0];
assertNotNull(type);
assertEquals(className, type.getName());
TypeVariableElement[] typeVariables = type.getTypeVariables();
assertLength(2, typeVariables);
assertEquals(firstVariableName, typeVariables[0].getName());
assertEquals(secondVariableName, typeVariables[1].getName());
assertFalse(type.isAbstract());
assertFalse(type.isSynthetic());
}
public void test_isMoreSpecificThan_typeArguments_transitivity_interfaceTypes() {
// class A {}
// class B extends A {}
//
ClassElement classA = classElement("A");
ClassElement classB = classElement("B", classA.getType());
InterfaceType typeA = classA.getType();
InterfaceType typeB = classB.getType();
TypeParameterElementImpl typeParameterT = new TypeParameterElementImpl(identifier("T"));
typeParameterT.setBound(typeB);
TypeParameterTypeImpl typeParameterTypeT = new TypeParameterTypeImpl(typeParameterT);
// <T extends B>
// T << A
assertTrue(typeParameterTypeT.isMoreSpecificThan(typeA));
}
public void test_visitClassDeclaration_minimal() {
ElementHolder holder = new ElementHolder();
ElementBuilder builder = new ElementBuilder(holder);
String className = "C";
ClassDeclaration classDeclaration = classDeclaration(null, className, null, null, null, null);
classDeclaration.accept(builder);
ClassElement[] types = holder.getTypes();
assertLength(1, types);
ClassElement type = types[0];
assertNotNull(type);
assertEquals(className, type.getName());
TypeVariableElement[] typeVariables = type.getTypeVariables();
assertLength(0, typeVariables);
assertFalse(type.isAbstract());
assertFalse(type.isSynthetic());
}
private void assertTypes(CompilationUnitElement unit, String... typeNames) {
assertNotNull(unit);
ClassElement[] types = unit.getTypes();
assertLength(typeNames.length, types);
for (ClassElement type : types) {
assertNotNull(type);
String actualTypeName = type.getName();
boolean wasExpected = false;
for (String expectedTypeName : typeNames) {
if (expectedTypeName.equals(actualTypeName)) {
wasExpected = true;
}
}
if (!wasExpected) {
fail("Found unexpected type " + actualTypeName);
}
}
}
public void test_visitClassDeclaration_withMembers() {
ElementHolder holder = new ElementHolder();
ElementBuilder builder = new ElementBuilder(holder);
String className = "C";
String typeVariableName = "E";
String fieldName = "f";
String methodName = "m";
ClassDeclaration classDeclaration =
classDeclaration(
null,
className,
typeParameterList(typeVariableName),
null,
null,
null,
fieldDeclaration(false, null, variableDeclaration(fieldName)),
methodDeclaration(
null,
null,
null,
null,
identifier(methodName),
formalParameterList(),
blockFunctionBody()));
classDeclaration.accept(builder);
ClassElement[] types = holder.getTypes();
assertLength(1, types);
ClassElement type = types[0];
assertNotNull(type);
assertEquals(className, type.getName());
assertFalse(type.isAbstract());
assertFalse(type.isSynthetic());
TypeVariableElement[] typeVariables = type.getTypeVariables();
assertLength(1, typeVariables);
TypeVariableElement typeVariable = typeVariables[0];
assertNotNull(typeVariable);
assertEquals(typeVariableName, typeVariable.getName());
FieldElement[] fields = type.getFields();
assertLength(1, fields);
FieldElement field = fields[0];
assertNotNull(field);
assertEquals(fieldName, field.getName());
MethodElement[] methods = type.getMethods();
assertLength(1, methods);
MethodElement method = methods[0];
assertNotNull(method);
assertEquals(methodName, method.getName());
}
@Override
public void apply(AngularHtmlUnitResolver resolver, XmlTagNode node) {
InterfaceType type = element.getType();
LocalVariableElementImpl variable = resolver.createLocalVariable(type, name);
resolver.defineVariable(variable);
}