org.eclipse.xtext.xbase.annotations.validation.UnresolvedFeatureCallTypeAwareMessageProvider Java Examples

@Test
public void testBrokenModel_11() throws Exception {
	XtendClass clazz = clazz("class C { def UnknownType m1() {} def void m2() { newArrayList(m1, m1).map[ it.unknownOperation ] }}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
	helper.assertError(clazz, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE, Diagnostic.LINKING_DIAGNOSTIC, "UnknownType cannot be resolved to a type.");
}
 

public void assertFeatureCallError(final XtendFile file, final EClass objectType) {
  final Resource resource = file.eResource();
  final List<Issue> allIssues = this._validationTestHelper.validate(resource);
  final Function1<Issue, Boolean> _function = (Issue it) -> {
    EObject object = resource.getResourceSet().getEObject(it.getUriToProblem(), true);
    final boolean featureCall = ArrayExtensions.contains(it.getData(), UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
    return Boolean.valueOf((((Objects.equal(it.getCode(), Diagnostic.LINKING_DIAGNOSTIC) && (it.getSeverity() == Severity.ERROR)) && 
      objectType.isInstance(object)) && featureCall));
  };
  final Iterable<Issue> match = IterableExtensions.<Issue>filter(allIssues, _function);
  boolean _isEmpty = IterableExtensions.isEmpty(match);
  if (_isEmpty) {
    Assert.fail("No Diagnostic.LINKING_DIAGNOSTIC issue with user data FEATURE_CALL found");
  }
}
 

@Test
public void testBrokenModel_12() throws Exception {
	XtendClass clazz = clazz("class C { def void m() { <UnknownType>newArrayList().map[ it.unknownOperation ] }}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
	helper.assertError(clazz, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE, Diagnostic.LINKING_DIAGNOSTIC, "UnknownType cannot be resolved to a type.");
}
 

@Test
public void testBrokenModel_10() throws Exception {
	XtendClass clazz = clazz("class C { def void m2() { #[ null as UnknownType ].head.unknownOperation }}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
	helper.assertError(clazz, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE, Diagnostic.LINKING_DIAGNOSTIC, "UnknownType cannot be resolved to a type.");
}
 

@Test
public void testBrokenModel_09() throws Exception {
	XtendClass clazz = clazz("class C { def void m2() { <UnknownType>newArrayList.head.unknownOperation }}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
	helper.assertError(clazz, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE, Diagnostic.LINKING_DIAGNOSTIC, "UnknownType cannot be resolved to a type.");
}
 

@Test
public void testBrokenModel_08() throws Exception {
	XtendClass clazz = clazz("class C { def UnknownType m1() {} def void m2() { m1.unknownOperation }}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
	helper.assertError(clazz, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE, Diagnostic.LINKING_DIAGNOSTIC, "UnknownType cannot be resolved to a type.");
}
 

@Test
public void testBrokenModel_06() throws Exception {
	XtendClass clazz = clazz("class C { UnknownType fieldName def void m() { fieldName.unknownOperation }}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
	helper.assertError(clazz, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE, Diagnostic.LINKING_DIAGNOSTIC, "UnknownType cannot be resolved to a type.");
}
 

@Test
public void testBrokenModel_05() throws Exception {
	XtendClass clazz = clazz("class C { @DoesNotExist(unknown='zonk') def void m() {}}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertError(clazz, XAnnotationsPackage.Literals.XANNOTATION, Diagnostic.LINKING_DIAGNOSTIC, "DoesNotExist cannot be resolved to an annotation type.");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testBrokenModel_04() throws Exception {
	XtendClass clazz = clazz("class C { def void m() { DoesNotExist::unknown }}");
	helper.assertNoError(clazz, IssueCodes.INCOMPATIBLE_TYPES);
	helper.assertError(clazz, XbasePackage.Literals.XFEATURE_CALL, Diagnostic.LINKING_DIAGNOSTIC, "DoesNotExist cannot be resolved to a type.");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

public QuickfixTestBuilder assertTypeLiteralLinkingIssue() {
  QuickfixTestBuilder _xblockexpression = null;
  {
    final Function1<Issue, Boolean> _function = (Issue it) -> {
      return Boolean.valueOf((Objects.equal(it.getCode(), Diagnostic.LINKING_DIAGNOSTIC) && 
        ArrayExtensions.contains(it.getData(), UnresolvedFeatureCallTypeAwareMessageProvider.TYPE_LITERAL)));
    };
    Assert.assertTrue(IterableExtensions.<Issue>exists(this.getIssuesAtCaret(), _function));
    _xblockexpression = this;
  }
  return _xblockexpression;
}
 

public QuickfixTestBuilder assertFeatureCallLinkingIssue() {
  QuickfixTestBuilder _xblockexpression = null;
  {
    final Function1<Issue, Boolean> _function = (Issue it) -> {
      return Boolean.valueOf((Objects.equal(it.getCode(), Diagnostic.LINKING_DIAGNOSTIC) && 
        ArrayExtensions.contains(it.getData(), UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL)));
    };
    Assert.assertTrue(IterableExtensions.<Issue>exists(this.getIssuesAtCaret(), _function));
    _xblockexpression = this;
  }
  return _xblockexpression;
}
 

protected boolean isUseJavaSearch(EReference unresolvedReference, Issue issue) {
	if (isConstructorReference(unresolvedReference))
		return true;
	if (isTypeReference(unresolvedReference))
		return true;
	if (Arrays.contains(issue.getData(), UnresolvedFeatureCallTypeAwareMessageProvider.TYPE_LITERAL)) {
		return true;
	}
	return false;
}
 

@Test
public void testBrokenModel_01() throws Exception {
	XtendClass clazz = clazz("class C { def m(DoesNotExist d) { d.unknown.unknown }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

/**
 * @since 2.9
 */
public Class<? extends ILinkingDiagnosticMessageProvider> bindILinkingDiagnosticMessageProvider() {
	return UnresolvedFeatureCallTypeAwareMessageProvider.class;
}
 

@Test
public void testInvalidPropertySugarBug403564_01() throws Exception {
	XtendClass clazz = clazz("class C { def String getSomething() { return something }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_02() throws Exception {
	XtendClass clazz = clazz("class C { def String isSomething() { return something }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_03() throws Exception {
	XtendClass clazz = clazz("class C { def void setSomething(String s) { something = '' }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_05() throws Exception {
	XtendClass clazz = clazz("class C { def String getURI() { return URI }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_06() throws Exception {
	XtendClass clazz = clazz("class C { def boolean isURI() { return URI }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_07() throws Exception {
	XtendClass clazz = clazz("class C { def void setURI(String s) { URI = '' }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_10() throws Exception {
	XtendClass clazz = clazz("class C { def String getX() { return x }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_11() throws Exception {
	XtendClass clazz = clazz("class C { def boolean isX() { return x }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}
 

@Test
public void testInvalidPropertySugarBug403564_12() throws Exception {
	XtendClass clazz = clazz("class C { def void setX(String s) { x = '' }}");
	helper.assertNoError(clazz, Diagnostic.LINKING_DIAGNOSTIC,UnresolvedFeatureCallTypeAwareMessageProvider.FEATURE_CALL);
}