eclipse.jdt.core | JDT/Core project repository | Code Editor library

Make sure you have the following in .settings/org.eclipse.jdt.core.prefs for that:

Well, there are 2 issues here:

1. PyDev does code-analysis based on how you configure it, so, you probably need to do here is provide stubs for PyDev to be able to find the needed names in your namespace (in this case you'd need stubs for the System.Resources -- the AddReadMe doesn't need it as it should be able to find the actual sources in this case).
2. PyDev has no way to know that some custom include() or loadModule() function actually does an import.

One option here could be providing the builtin modules for PyDev in the form of predefined completions: https://www.pydev.org/manual_101_interpreter.html#PyDevInterpreterConfiguration-PredefinedCompletions (or create Python module stub-files).

Then, to make it actually find that, do something as an import in an if False (so, PyDev will consider it in code-analysis even though it won't be executed):

1. Close Eclipse IDE
2. Go to your workspace directory e.g: workspace/.metadata/.plugins/org.eclipse.debug.core/.launches (for linux I use command "locate .launch" to quick find)
3. Find your broken Launching configuration in this directory, and open it with a text editor
4. Check these two lines is exist, if not exist, you must add these two lines with your 'value="web"' module name. If you don't know the module name, just create a new "Run Configuration" and find differences with the previous "Run Configuration" in the .launch file

Now that I know the reason it sounds easy, but it really took me some time to figure that out. It was a chain of dependencies that led to this strange behavior:

1. In my STS I have installed the Jaspersoft Studio.
2. In the Java Build Path of the kita-formular-boot project I have added another project (kita-resources) as a required project.
3. kita-resources contains some jrxml files. To get them compiled I have added JasperReports Nature to the project.
4. While doing so the JasperReports Library Dependencies were automatically added in the Java Build Path.
5. These dependencies include the older spring-core version which was causing the trouble.

By setting kita-resources as required project all classpaths from kita-resources were also included in kita-formular-boot. So all I had to do was to remove the JasperReports Library Dependencies from the Java Build Path in kita-resources. Obviously they aren't necessary to compile the project. And all conflicts are gone!

It is used to be bug with the current folder .I have resolved the problem by creating a new folder and move my project there .

This looks like Eclipse bug 564329 which is marked as fixed in Eclipse core 4.17 M1 (Milestone 1). So this fix will be in the 2020-09 release scheduled for September 2020.

Do experiments on org.eclipse.core version. You might need to upgrade the version of org.eclipse.birt.runtime. Select the version that contains the method SubMonitor.split().

The @NotNull, unwanted in your case, will be added if and only if annotation-based null analysis is not enabled or misconfigured.

In Project > Properies: Java > Compiler in the section Null analysis:

1. Make sure the checkbox Enable annotation-based null analysis is checked
2. Instead of the checkbox Use default annotation for null specification being checked, click the Configure... link and configure test.NotNull (or org.jetbrains.annotations.NotNull) as 'NonNull' annotation

Please note, only ElementType.TYPE_USE annotations will be added. For methods annotated with an ElementType.TYPE_USE annotation (which cannot be added to void methods), the annotation refers to the return type, not to the method itself. In other words, you get an annotated object when calling such a method. For me, to add an Use of a type annotations to the type of a variable is the expected behavior.

It only becomes unclear for annotations like in your case that have both targets, ElementType.TYPE_USE and ElementType.METHOD. Does the annotation refer to the return type (so it make sense to add it) or does the method refer to the method itself (and therefore it should not be added)?

Please not also, in contrast to org.jetbrains.annotations.NotNull org.eclipse.jdt.annotation.NonNull has no target ElementType.METHOD. How can a method declaration be null? What is the meaning of a @NotNull method? According to the Javadoc of org.jetbrains.annotations.NotNull ("... null value is forbidden to return (for methods)..."), the target ElementType.METHOD seems to be added by mistake here, since it does not refer to the method declaration.

I received assistance from the folks working on the XText Gradle plug-in via https://github.com/xtext/xtext-gradle-plugin/issues/171.

The biggest issue is that src-gen cannot exist on the classpath prior to execution of the generateXText task. To assist with this updating the clean task to remove the src-gen folder is recommended. Additionally, the second 3 compile dependencies should be xtextLanguages dependencies.