6314730DEV3147-66cbc2c723-27
Make duplicate names catcher more powerful. This test pack is disabled now because names duplication is not caught here. It happens because of "duplicate-names.xsl" thinks that abstract objects in the tests are on the different levels. Syntactically they are, but semantically they're not. So we need to make this duplicate catcher more powerful, enable the test by removing "skip: true" line and make sure it works.
src/test/resources/org/eolang/lints/errors/catches-conflict-with-auto-name.yaml@yegor256yegor256@gmail.com341435DEV14-e039e30739-42
Calculate comment line number with abusive character. For now we just reusing object line number (via @line), which is not correct for specifying on which line of the program comment is located. This issue can be solved after <a href="https://github.com/objectionary/eo/issues/3536">this one</a>.
src/main/java/org/eolang/lints/comments/AsciiOnly.java@rultorme@rultor.com411945DEV19-80f5b41d45-47
Create Lint envelope called `JavaLint` that will fetch motive from Markdown file based on the lint's name (Java class name) and lint's dimension (Java package name, e.g. `comments`).
src/main/java/org/eolang/lints/comments/AsciiOnly.java@yegor256yegor256@gmail.com421935DEV19-33379f103-5
Document motives for `not-empty-atoms` lint. Currently, we don't have a test case for this `not-empty-atoms` lint. We should create a new test case, and then document a motive for this lint.
src/main/resources/org/eolang/motives/critical/not-empty-atoms.md@yegor256yegor256@gmail.com431935DEV19-e20aed593-5
Document motives for `same-line-names` lint. Currently, we don't have a test case for this `same-line-names` lint. We should create a new test case, and then document a motive for this lint.
src/main/resources/org/eolang/motives/critical/same-line-names.md@yegor256yegor256@gmail.com441935DEV19-ccc6357f5-8
Document motives and examples for `empty-object` lint. Currently, we don't have a test case for this `empty-object` lint. We should create a new test case, and then document a motive with examples for this lint.
src/main/resources/org/eolang/motives/errors/empty-object.md@yegor256yegor256@gmail.com451930DEV19-c076b49011-13
Document more about `broken-refs` lint. Currently, there is no unit test that finds defects with broken refs. Let's add a few, and only then add more docs in broken-ref's motive.
src/main/resources/org/eolang/motives/refs/broken-refs.md@yegor256yegor256@gmail.com1257260DEV72-f7af213e49-53
Configure maven to download model file during the build and place into the JAR. Currently, we download model file each time when creating the lint, which may be slow in the usage of this lint. Instead, let's configure maven to download model file during the build, and place into JAR, so lint will be able to locate file from resources faster.
src/main/java/org/eolang/lints/misc/UnitTestIsNotVerb.java@rultorme@rultor.com13512960DEV129-28f9134856-60
Library stanford-corenlp-4.5.7-models.jar takes too much in size. Currently, JAR takes ~452mb, which may cause some troubles to the users of the lints library. Let's think what we can do about this. We should check is it possible to get rid of this dependency and download models from the other source.
src/main/java/org/eolang/lints/misc/UnitTestIsNotVerb.java@rultorme@rultor.com14313445DEV134-6f7709d554-58
Measure lint time for smaller/larger classes, similar way to JNA Pointer. Currently, we measure linting of just one big class. Would be good to measure other classes in size too, for instance smaller classes (standard program), large class (JNA pointer), x-large class, and xxl class. Don't forget to adjust lint-summary.txt file to capture all the measurements.
src/test/java/org/eolang/lints/ProgramTest.java@yegor256yegor256@gmail.com47014335DEV143-358342b330-33
Add JMH benchmarks result reporting. Currently, there is no reporting of benchmark results. Let's add <a href="https://github.com/volodya-lombrozo/jmh-benchmark-action">this</a> GitHub Actions plugin and configure it to run on each PR.
src/test/java/benchmarks/ProgramBench.java@rultorme@rultor.com14413490DEV134-6deff79b59-64
Capture all the lint timings in timings.csv. Currently, we just capture total time - amount of milliseconds was required to lint some XMIR. Would be helpful to get extended statistics - timings of each lint. Don't forget to include this information into lint-summary.txt. You can check how it was implemented in HONE: <a href="https://github.com/objectionary/hone-maven-plugin/blob/master/src/main/java/org/eolang/hone/Timings.java">Timings.java</a>.
src/test/java/org/eolang/lints/ProgramTest.java@yegor256yegor256@gmail.com19014435DEV144-43965ba3319-322
Resolve code duplication with Program.java class. Currently, BcProgram.java is duplication of Program.java. Let's make it use the original Program.java, so they will stay synced. Don't forget to remove this puzzle.
src/test/java/org/eolang/lints/ProgramTest.java@yegor256yegor256@gmail.com50914435DEV144-a2c4deb3436-439
Resolve code duplication with Source.java class. Currently, BcSource.java is duplication of Source.java. Let's make it use the original Source.java, so they will stay synced. Don't forget to remove this puzzle.
src/test/java/org/eolang/lints/SourceTest.java@h1alexbelh1alexbelx@gmail.com15714830DEV148-2fd39dd638-43
Test or remove {@link Defect#rule()} method. This method is not used by any class in the project. Moreover, we don't even have a test for it. We should either test it or remove it. Actually, this method is used <a href="https://github.com/objectionary/lints/pull/150/files#r1888310583">somewhere</a>
src/main/java/org/eolang/lints/Defect.java@rultorme@rultor.com15814830DEV148-092aa30a38-40
The {@link XslLints} class should implement {@link Lint} instead. Currently, this class is used as an iterable of lints, but it should be used as a single lint that aggregates other lints.
src/main/java/org/eolang/lints/XslLints.java@rultorme@rultor.com16014830DEV148-e3c5890738-40
The {@link PkByXsl} class should implement {@link Lint} instead. Currently, this class is used as an iterable of lints, but it should be used as a single lint that aggregates other lints.
src/main/java/org/eolang/lints/PkByXsl.java@yegor256yegor256@gmail.com19214935DEV149-6bce14ac165-167
Introduce new class XmirKey.java Let's extract the code that calculates the key for XMIR file into new Java class. Don't forget to create unit tests, and remove this puzzle.
src/main/java/org/eolang/lints/Programs.java@yegor256yegor256@gmail.com21510745DEV107-b3a5bdea23-25
Configure default timeout for tests running on windows to 10s and 3s on other platforms. Currently, it fails with the 3s timeout on windows platform. Let's try to configure test default timeout exclusively for windows, and keep 3s for other platforms.
src/test/resources/junit-platform.properties@yegor256yegor256@gmail.com21619930DEV199-3cb36c43170-176
Use {@link XML#xpath(String)} Method Instead. This method is using a custom implementation to find the name of the program. We should replace it with the {@link XML#xpath(String)} method to make the code cleaner. You can use `program.xpath("/program/@name").stream().findFirst().orElse("unknown")` to find the name. This issue is blocked by <a href="https://github.com/jcabi/jcabi-xml/issues/289">jcabi/jcabi-xml#289</a>.
src/main/java/org/eolang/lints/LtByXsl.java@yegor256yegor256@gmail.com21719930DEV199-c82777d8188-194
Use {@link XML#nodes(String)} Method Instead. This method is using a custom implementation to find defects in the report. We should replace it with the {@link XML#nodes(String)} method to make the code cleaner. You can use `report.nodes("/defects/defect")` to find the defects. This issue is blocked by <a href="https://github.com/jcabi/jcabi-xml/issues/288">jcabi/jcabi-xml#288</a>.
src/main/java/org/eolang/lints/LtByXsl.java@yegor256yegor256@gmail.com27625760DEV257-9496b6b452-56
Configure model download only during the build and place into the JAR. Currently, we download model file each time when creating the lint, which may be slow in the usage of this lint. Instead, let's configure maven to download model file during the build, and place into JAR, so lint will be able to locate file from resources faster.
src/main/java/org/eolang/lints/misc/LtTestNotVerb.java@yegor256yegor256@gmail.com31329735DEV297-589ae9b741-45
Return `LtTestNotVerb` back. For some reason this lint produces errors in EO-to-Java Compiler. Check <a href="https://github.com/objectionary/lints/issues/297#issuecomment-2636540673">this</a> issue for more details. We should return it in the fixed state, once we understand the root cause of the problem.
src/main/java/org/eolang/lints/PkMono.java@yegor256yegor256@gmail.com36525960DEV259-5bf6866f24-28
Optimize performance of inconsistent arguments finding. Instead of re-collecting objects in nested loops, we should merge all objects from all programs into single XMIR under '<objects/>' element. After objects are merged, we can iterate over all the objects there only once, and find inconsistencies.
src/main/java/org/eolang/lints/LtInconsistentArgs.java@yegor256yegor256@gmail.com37236890DEV368-1edf74b716-18
Implement lint caching decorator. We should cache `Lint.defects()` to cache found defects when calling particular lint. Don't forget to add unit tests, and benchmark tests.
src/main/java/org/eolang/lints/Lint.java@yegor256yegor256@gmail.com38536845DEV368-78b44b68112-116
Configure `unlint-non-existing-defect` lint to ignore unlints from other scope (WPA/Single program). On WPA side of this lint ({@link LtUnlintNonExistingDefectWpaTest}) we should ignore single program lints. Also, don't forget to enable {@link LtUnlintNonExistingDefectWpaTest#ignoresSingleProgramUnlint()}.
src/test/java/org/eolang/lints/LtUnlintNonExistingDefectTest.java@yegor256yegor256@gmail.com39238630DEV386-d4b4e10820-24
Replace `XML.xpath()` with `Xnav.path()` usage in defects() method. Currently, we cannot use `Xnav.path()` method due to <a href="https://github.com/volodya-lombrozo/xnav/issues/74">this</a> bug. Once it will be resolved, we should replace `XML.xpath()` with `Xnav.path()` in order to improve the performance of the `LtUnlint.defects()` execution.
src/main/java/org/eolang/lints/LtUnlint.java@yegor256yegor256@gmail.com40539425DEV394-da4e25ec95-97
Replace `LtAlways` in comparison with lint caching decorator. Currently, its not available, once <a href="https://github.com/objectionary/lints/issues/372">this</a> ticket will be solved, we can replace the class.
src/test/java/org/eolang/lints/PkMonoTest.java@yegor256yegor256@gmail.com43642960DEV429-a4557e2426-29
Convert all found {@link Defect}-s into XML and then assert using XPath. For now we are using custom asserts outlined in implementations of {@link Assertion} interface. Conversion to XML document can eliminate the need to custom asserts, since we will be able to utilize XPath expressions similarly as in {@link XtYaml#asserts()}.
src/test/java/org/eolang/lints/WpaStory.javah1alexbelh1alexbelx@gmail.com46516560DEV165-a8f393c823-28
Add {@link LtReservedName} to the LINTS Mono pipeline. Currently, it will cause timeout exceptions in several places in tests, due to the design of {@link LtReservedName}. There, it scans all the home EO objects, pulled from Git by maven in the `generate-sources` phase, and process them. Will be great to process home objects only once - initially during the build, and then reuse it everywhere.
src/main/java/org/eolang/lints/MonoLints.java@rultorme@rultor.com60246545DEV465-7c10eaab31-35
Refactor HomeNames. Currently, the class does two things: 1) Object name parsing, and 2) CSV placing. Let's refactor it to make it aligned with <a href="https://en.wikipedia.org/wiki/Single-responsibility_principle">SRP</a>. Probably one new class will be required (for name parsing), together with proper naming of this one (for placing them into CSV).
src/main/groovy/org/eolang/lints/HomeNames.groovy@h1alexbelh1alexbelx@gmail.com50225960DEV259-23892a1e26-30
Optimize performance of inconsistent arguments finding. Instead of re-collecting objects in nested loops, we should merge all objects from all programs into single XMIR under '<o/>' element. After objects are merged, we can iterate over all the objects there only once, and find inconsistencies.
src/main/java/org/eolang/lints/LtInconsistentArgs.java@rultorme@rultor.com52040215DEV402-462e483a31-34
Replace the creation of new ArrayList<>(0) with the creation of ArrayList<>() without a constructor argument in whole project. Add ignore warning ConditionalRegexpMultilineCheck from Checkstyle (it doesn't seem to be possible at the moment <a href="https://github.com/yegor256/qulice/issues/1328">issue 1328</a>)
src/main/java/org/eolang/lints/LtAsciiOnly.java@rultorme@rultor.com56355535DEV555-aaf5c23c44-46
Enable `duplicate-names-in-diff-context` benchmark. Currently, its slow, especially for `L` and `XL`-sized sources. Let's optimize it, in order to enable this benchmark.
src/test/java/benchmarks/SourceBench.java@h1alexbelh1alexbelx@gmail.com59237660DEV376-92eafa5248-51
Enable redundant object in the single XMIR scope benchmarks. As for now, the lint is too slow, especially on L, XL and XXL-sized XMIRs. This happens mostly because of multiple XPath `//o` selects in the XSL. Once, the lint will be optimized, we can enable the lint in the benchmarks.
src/test/java/benchmarks/SourceBench.java@yegor256yegor256@gmail.com62739330DEV393-4973abd922-26
DEV Introduce LfDfSticky integration tests. LfDfSticky is used in PkMono and PkWpa, which in turn are used in Program and Programs. Run Program::defects and Programs::defects separately and check that caching works correct. Important to note that specific Lint implementation is highly coupled with PkMono class, which in turn is used in Program's most used constructor, so probably Program(s) refactoring is required.
src/main/java/org/eolang/lints/LtDfSticky.java@yegor256yegor256@gmail.com65262460DEV624-70aa78e15-10
Enable `catches-inconsistency-in-nested-anonymous-formations` test story. For now, its disabled because `LtInconsistentArgs` fails to convert parent tree with anonymous objects to searchable XPath for the XMIR. We should change our logic in both `LtInconsistentArgs#voidFqn()` and `VoidXpath`. Don't forget to enable `catches-inconsistency-resolving-anonymous-path.yaml`, `catches-inconsistency-when-parent-object-lacks-name.yaml`, and test stories as well.
src/test/resources/org/eolang/lints/packs/wpa/inconsistent-args/catches-inconsistency-in-nested-anonymous-formations.yamlYegor Bugayenkoyegor256@gmail.com68054060DEV540-1cf7838e10-14
Add a new style package - `write-good` - to both this list and the package list. Then fix all the issues it reports(there will be a lot). It’s better to run Vale locally to find issues, since the GitHub Action outputs the list in a less readable format when there are many errors. format due to the large number of errors.
.vale.ini@Marat-Tim108345628+Marat-Tim@users.noreply.github.com68567635DEV676-fcdc9c7d12-16
Remove `+unlint application-without-as-attributes`. Currently, eo-parser does not generate `@as` attributes for applications, once we will resolve the problem in parser: https://github.com/objectionary/eo/issues/4382, we should enable it in all the places, including: `SourceTest#returnsEmptyListOfDefects` and `SourceTest#returnsOnlyOneDefect`.
src/test/resources/org/eolang/lints/canonical.eoAliaksei Bialiauskih1alexbelx@gmail.com68667145DEV671-0cafd5ba17-21
Adjust `DefectMissing` to handle unlints with line ranges. Currently we don't support such line ranges in this and {@link LtUnlintNonExistingDefectWpa} lint, but we should, since {@link LtUnlint} supports them. If we will add the support of line ranges here, `unlint-non-existing-defect` in both scopes should catch up it. Don't forget to add tests for both scopes.
src/main/java/org/eolang/lints/DefectMissing.java@h1alexbelh1alexbelx@gmail.com71571145DEV711-894ffa0c387-390
Enable `hone` profile on all platforms after. For now, `hone-maven-plugin` fails on `macOS` and `Windows` machines. After the issue will be fixed, we should `<os/>` element from the `<activation/>` and keep `activeByDefault=true`.
pom.xml@h1alexbelh1alexbelx@gmail.com72371635DEV716-7b35e97f17-21
Enable hone.yml and jmh.yml (hone-dependent workflow) after hone will be fixed. At present, the hone is unable to generate the correct optimized byte code for Groovy, see this issue: https://github.com/objectionary/hone-maven-plugin/issues/297. Also, the plugin run is time-consuming, we should enable it only after the plugin will have stable execution time, in order to not disturb the development in this repository.
.github/workflows/hone.yml@h1alexbelh1alexbelx@gmail.com76976760DEV767-c4e8991565-68
Decrease timeouts for source linting. As for now, most lints are too slow, we need to optimize them first, so they run in milliseconds, not seconds/minutes. It should decrease our build time too. After that, we need to decrease our test timeouts. Don't forget to remove this puzzle.
src/test/java/org/eolang/lints/SourceTest.javaAliaksei Bialiauskih1alexbelx@gmail.com87086790DEV867-3b63a0b070-75
Standardize EO test programs by using .eo files instead of inline strings. Currently, EO programs used in tests (e.g. in MonoLintsTest, PkByXslTest) are constructed from hard-coded String.join(...) calls scattered across test classes. This makes them hard to maintain and inconsistent. All such inline EO snippets should be extracted into dedicated .eo resource files under src/test/resources and loaded via ResourceOf, so that every test reads its input from a single canonical source.
src/test/java/org/eolang/lints/MonoLintsTest.java@volodya-lombrozovolodya.lombrozo@gmail.com87287090DEV870-2650a22a52-58
Reduce total execution time of LtByXslTest below 60 seconds. The full test suite in this class takes ~197 seconds to run (360 tests), which is too slow for a regular build. Investigate which parameterized or integration tests dominate the runtime (likely {@code testsAllLintsByEo} and similar classpath-scanning suites), and consider splitting heavy tests into a separate integration-test profile, parallelising test execution, or caching parsed XMIR across test cases where it is safe to do so.
src/test/java/org/eolang/lints/LtByXslTest.java@volodya-lombrozovolodya.lombrozo@gmail.com87987260DEV872-aad6505526-32
Extract name-validation logic from LtTestNotVerb into a testable component. Currently {@link LtTestNotVerbTest} parses many EO programs that differ only in the object name being tested, making the tests slow and hard to maintain. The name-validation predicate (verb vs. non-verb check) should be extracted into its own class so it can be tested directly with plain strings — no EO parsing required. Once extracted, reduce {@link LtTestNotVerbTest} to a few representative end-to-end cases and add a dedicated unit test class for the new component.
src/test/java/org/eolang/lints/LtTestNotVerbTest.javavolodya-lombrozovolodya.lombrozo@gmail.com87387060DEV870-99c16e0859-65
Deduplicate EO resource files under src/test/resources/org/eolang/lints/. We now have 46 small {@code .eo} fixture files added during the extraction of inline EO programs. Some of these files may contain identical or semantically equivalent programs (e.g. {@code foo-without-dot.eo}, {@code first-foo.eo}, {@code simple.eo}). Audit all fixture files for content duplicates and consolidate where possible, updating test references to point to the surviving canonical file. This reduces maintenance burden and avoids subtle divergence between "the same" EO program defined twice.
src/test/java/org/eolang/lints/LtByXslTest.javavolodya-lombrozovolodya.lombrozo@gmail.com87487090DEV870-3df121a471-76
Introduce EoProgram helper class to wrap EO resource parsing. In many test classes we repeat {@code new EoSyntax(new ResourceOf("...")).parsed()}. Extract this into a dedicated {@code EoProgram(String resource)} class with a {@code parse()} method that handles {@link java.io.IOException} gracefully, logs parse timing, and provides a minimal in-memory cache so the same resource is not re-parsed across multiple test methods.
src/test/java/org/eolang/lints/MonoLintsTest.javavolodya-lombrozovolodya.lombrozo@gmail.com90289660DEV896-45229a6d20-25
Replace partial meta comparison with exact XMIR match. Currently the test only compares the ordered sequence of "head tail" strings extracted from the metas section. Since we have a clear 'input' and 'output' EO program in each YAML pack, we should compare the full XMIR structure of the fixed result against the expected XMIR, ignoring only volatile attributes such as @line numbers.
src/test/java/org/eolang/lints/FxUnsortedMetasTest.java@volodya-lombrozovolodya.lombrozo@gmail.com91389630DEV896-2b0e002a56-60
Replace String.format with FormattedText in this constructor. FxResource currently accepts a String, so String.format is used here, triggering ConstructorsCodeFreeCheck. Change FxResource to accept a Text object and pass new FormattedText("org/eolang/fixes/%s.xsl", xsl) instead, consistent with how ResourceOf is used for the lint and motive paths above.
src/main/java/org/eolang/lints/LtByXsl.java@volodya-lombrozovolodya.lombrozo@gmail.com91489660DEV896-60b82aa854-59
Make FxResource accept full URL strings so that the fix path can be derived with the same LINTS_PATH pattern replacement used for motives, dropping the intermediate xsl variable. Currently FxResource.load() uses ClassLoader.getResource() which expects a classpath-relative path, not a full jar:/file: URL, so the two derivation approaches cannot be unified yet.
src/main/java/org/eolang/lints/PkByXsl.java@volodya-lombrozovolodya.lombrozo@gmail.com107271145DEV711-48ded10d384-388
Enable `hone` profile on all platforms after. For now, `hone-maven-plugin` fails on `macOS` and `Windows` machines. After the issue will be fixed, we should `<os/>` element from the `<activation/>` and keep `activeByDefault=true`. -->
pom.xml@volodya-lombrozovolodya.lombrozo@gmail.com1212117225DEV1172-e9cb8f304-7
Enable `catches-package-duplicate` after fix in EO parser. Current EO version fails to parse EO with multiple `+package` metas. See this for more details: https://github.com/objectionary/eo/issues/6395. Once it will be fixed and realised, we can enable this test again.
src/test/resources/org/eolang/lints/packs/single/duplicate-metas/catches-package-duplicate.yamlRultor.comgpg@rultor.com1236110130DEV1101-c0ed88ca155-163
Decide whether canonical.eo should drop the `>>` on nested formations like `[i] >>`/`[i1] >>`, or whether `redundant-attachment` should gain a documented exception for formations that capture outer scope via `^`/`ρ`. The `>>` there is not structurally required (parsing and scope resolution work identically without it, verified empirically), but it may still be idiomatic for closures over outer state. Raise this with the EO language/parser maintainers; for now the lint is suppressed on canonical.eo via `+unlint redundant-attachment`.
src/test/java/org/eolang/lints/SourceTest.java@volodya-lombrozovolodya.lombrozo@gmail.comunknown132160DEV1321-6aa5702145-102
Name the shapes this lint still misses. The compiler also leaves the recursion alone when the self-call is spelled "Phi.name" instead of "^.name", when the formation is reached other than by a plain application, as a decoratee or as the receiver of a dispatch, when an attribute holding a self-call is read from outside the formation, as in "range", and when two formations call each other. Each of those is syntactic, so each can be found here and reported with a reason of its own, the way the four below are. --> <!-- A nested formation that calls itself has its recursion turned into a Java loop, one copy of the object per step instead of one Java stack block, but only when the compiler recognises the shape. When it does not, the program still runs, only deeper and slower, and nothing says so at the call site. We say it here. --> <xsl:template match="/"> <defects> <xsl:for-each select="//o[eo:abstract(.) and @name and parent::o and o[@name='φ']]"> <xsl:variable name="self" select="concat('ξ.ρ.', @name)"/> <xsl:variable name="root" select="o[@name='φ']"/> <xsl:variable name="calls" select=".//o[@base = $self or starts-with(@base, concat($self, '.'))]"/> <xsl:variable name="loops" select="($root | $root//o)[@base = $self and eo:tail(., $root)]"/> <xsl:if test="exists($calls) and empty($loops)"> <defect> <xsl:variable name="line" select="eo:lineno($calls[1]/@line)"/> <xsl:attribute name="line"> <xsl:value-of select="$line"/> </xsl:attribute> <xsl:if test="$line = '0'"> <xsl:attribute name="context"> <xsl:value-of select="eo:defect-context(.)"/> </xsl:attribute> </xsl:if> <xsl:attribute name="severity">warning</xsl:attribute> <xsl:attribute name="experimental">true</xsl:attribute> <xsl:text>The recursion in </xsl:text> <xsl:value-of select="eo:escape(@name)"/> <xsl:text> cannot be turned into a loop, </xsl:text> <xsl:choose> <xsl:when test="o[@name='λ']"> <xsl:text>the formation is an atom</xsl:text> </xsl:when> <xsl:when test=".//o[contains(@base, 'φ')]"> <xsl:text>its body reads its own φ</xsl:text> </xsl:when> <xsl:when test="$calls[starts-with(@base, concat($self, '.'))]"> <xsl:text>the self-call is the receiver of a dispatch</xsl:text> </xsl:when> <xsl:otherwise> <xsl:text>no self-call sits in a tail position</xsl:text> </xsl:otherwise> </xsl:choose> </defect> </xsl:if> </xsl:for-each> </defects> </xsl:template>
src/main/resources/org/eolang/lints/design/unoptimizable-recursion.xslmorphqddeuropeDreadlyDevil@gmail.com1336104630DEV1046-9060248b11-73
Report the exact physical line of the too-wide line inside a multi-line comment. Right now every offending line is reported with the comment block's own start @line, since the XSL has no way to compute the offset of a line within the tokenized comment text. Add a $pos-based offset (comment @line + position() - 1) so catches-multiline-wide-comment.yaml can assert on line 2 (the actual offending line) instead of line 1. --> <xsl:template match="/"> <xsl:variable name="max" select="100"/> <defects> <xsl:for-each select="/object/comments/comment"> <xsl:variable name="line" select="if (@line) then @line else '0'"/> <xsl:variable name="lines" select="tokenize(replace(., '\\n', ' '), ' ')"/> <xsl:choose> <xsl:when test="count($lines) > 1"> <xsl:for-each select="$lines[string-length(.) > $max]"> <xsl:element name="defect"> <xsl:attribute name="line"> <xsl:value-of select="$line"/> </xsl:attribute> <xsl:if test="$line = '0'"> <xsl:attribute name="context"> <xsl:value-of select="eo:defect-context(.)"/> </xsl:attribute> </xsl:if> <xsl:attribute name="severity"> <xsl:text>warning</xsl:text> </xsl:attribute> <xsl:text>The comment line width is </xsl:text> <xsl:value-of select="string-length(.)"/> <xsl:text>, while </xsl:text> <xsl:value-of select="$max"/> <xsl:text> is max allowed</xsl:text> </xsl:element> </xsl:for-each> </xsl:when> <xsl:otherwise> <xsl:if test="string-length(.) > $max"> <xsl:element name="defect"> <xsl:attribute name="line"> <xsl:value-of select="$line"/> </xsl:attribute> <xsl:if test="$line = '0'"> <xsl:attribute name="context"> <xsl:value-of select="eo:defect-context(.)"/> </xsl:attribute> </xsl:if> <xsl:attribute name="severity"> <xsl:text>warning</xsl:text> </xsl:attribute> <xsl:text>The comment width is </xsl:text> <xsl:value-of select="string-length(.)"/> <xsl:text>, while </xsl:text> <xsl:value-of select="$max"/> <xsl:text> is max allowed</xsl:text> </xsl:element> </xsl:if> </xsl:otherwise> </xsl:choose> </xsl:for-each> </defects> </xsl:template>
src/main/resources/org/eolang/lints/comments/comment-is-too-wide.xsl@volodya-lombrozovolodya.lombrozo@gmail.com1343127130DEV1271-e767249a25-28
Let XtLint accept EO sources (the {@code input:} pack key) in addition to raw XMIR documents, so that Java-implemented lints can be tested from EO programs the same way XSL-based lints are tested, instead of the hand-written {@code document:} blocks that the current packs use.
src/test/java/org/eolang/lints/XtLint.java@rultorgpg@rultor.comunknown132160DEV1321-eda8fa4945-132
Name the shapes this lint still misses. The compiler also leaves the recursion alone when the self-call is spelled "Phi.name" instead of "^.name", when the formation is reached other than by a plain application, as a decoratee or as the receiver of a dispatch, when an attribute holding a self-call is read from outside the formation, as in "range", and when two formations call each other. Each of those is syntactic, so each can be found here and reported with a reason of its own, the way the four below are. --> <!-- TRUE when the @base is a self-call of the object with the given name, in any of the three forms the parser emits: the plain name resolves to "Phi.<name>", the "^" form to "xi.rho.<name>", and the "$" form to "xi.<name>". A dispatch on the self-call is also a self-call. --> <xsl:function name="eo:is-self-call" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="$base = concat('Φ.', $name) or starts-with($base, concat('Φ.', $name, '.')) or $base = concat('ξ.ρ.', $name) or starts-with($base, concat('ξ.ρ.', $name, '.')) or $base = concat('ξ.', $name) or starts-with($base, concat('ξ.', $name, '.'))"/> </xsl:function> <!-- TRUE when the @base is a dispatch on a self-call, i.e. the self-call is the receiver and a method is dispatched on it. --> <xsl:function name="eo:is-self-dispatch" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="starts-with($base, concat('Φ.', $name, '.')) or starts-with($base, concat('ξ.ρ.', $name, '.')) or starts-with($base, concat('ξ.', $name, '.'))"/> </xsl:function> <!-- TRUE when the @base is a self-call in a tail position: the plain call of the object, with no method dispatched on it. A dispatch on the self-call is never a tail call, because the receiver is evaluated, not the call. --> <xsl:function name="eo:is-self-tail" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="$base = concat('Φ.', $name) or $base = concat('ξ.ρ.', $name) or $base = concat('ξ.', $name)"/> </xsl:function> <!-- A nested formation that calls itself has its recursion turned into a Java loop, one copy of the object per step instead of one Java stack block, but only when the compiler recognises the shape. When it does not, the program still runs, only deeper and slower, and nothing says so at the call site. We say it here. --> <xsl:template match="/"> <defects> <xsl:for-each select="//o[eo:abstract(.) and @name and o[@name='φ']]"> <xsl:variable name="name" select="string(@name)"/> <xsl:variable name="root" select="o[@name='φ']"/> <xsl:variable name="calls" select=".//o[eo:is-self-call(string(@base), $name)]"/> <xsl:variable name="loops" select="($root | $root//o)[eo:is-self-tail(string(@base), $name) and eo:tail(., $root)]"/> <xsl:if test="exists($calls) and empty($loops)"> <defect> <xsl:variable name="line" select="eo:lineno($calls[1]/@line)"/> <xsl:attribute name="line"> <xsl:value-of select="$line"/> </xsl:attribute> <xsl:if test="$line = '0'"> <xsl:attribute name="context"> <xsl:value-of select="eo:defect-context(.)"/> </xsl:attribute> </xsl:if> <xsl:attribute name="severity">warning</xsl:attribute> <xsl:attribute name="experimental">true</xsl:attribute> <xsl:text>The recursion in </xsl:text> <xsl:value-of select="eo:escape(@name)"/> <xsl:text> cannot be turned into a loop, </xsl:text> <xsl:choose> <xsl:when test="o[@name='λ']"> <xsl:text>the formation is an atom</xsl:text> </xsl:when> <xsl:when test=".//o[contains(@base, 'φ')]"> <xsl:text>its body reads its own φ</xsl:text> </xsl:when> <xsl:when test="$calls[eo:is-self-dispatch(string(@base), $name)]"> <xsl:text>the self-call is the receiver of a dispatch</xsl:text> </xsl:when> <xsl:otherwise> <xsl:text>no self-call sits in a tail position</xsl:text> </xsl:otherwise> </xsl:choose> </defect> </xsl:if> </xsl:for-each> </defects> </xsl:template>
src/main/resources/org/eolang/lints/design/unoptimizable-recursion.xslVasilev Stas33578155+VasilevNStas@users.noreply.github.com1421141930DEV1419-4154c11827-35
Emit a {@code rule} attribute on each generated {@code <defect>} element, carrying {@link Defect#rule()}. Right now the produced XML only has {@code line}, {@code severity}, and text, so a pack's {@code asserts:} can't check which rule fired a defect. This blocks moving Java tests such as {@code LtAsciiOnlyTest#setsRuleCorrectly} (and any similar rule-name assertion in other {@code Lt*Test} classes) into YAML packs. Once the attribute is added, convert those tests into packs with an {@code asserts:} XPath checking {@code @rule}.
src/test/java/org/eolang/lints/XtLint.java@volodya-lombrozovolodya.lombrozo@gmail.com1429142130DEV1421-d013175227-32
Move the rule-name assertions into YAML packs. Now that each {@code <defect>} carries {@code @rule}, a pack's {@code asserts:} can check which rule fired, so Java tests that exist only to assert a rule name, such as {@code LtAsciiOnlyTest#setsRuleCorrectly}, can become packs with an {@code asserts:} XPath on {@code @rule} and be deleted from Java.
src/test/java/org/eolang/lints/XtLint.java@opusstudiohq-maxopus.studio.hq@gmail.com1426132160DEV1321-e353204445-132
Name the shapes this lint still misses. The compiler also leaves the recursion alone when the self-call is spelled "Phi.name" instead of "^.name", when the formation is reached other than by a plain application, as a decoratee or as the receiver of a dispatch, when an attribute holding a self-call is read from outside the formation, as in "range", and when two formations call each other. Each of those is syntactic, so each can be found here and reported with a reason of its own, the way the four below are. --> <!-- TRUE when the @base is a self-call of the object with the given name, in any of the three forms the parser emits: the plain name resolves to "Phi.<name>", the "^" form to "xi.rho.<name>", and the "$" form to "xi.<name>". A dispatch on the self-call is also a self-call. --> <xsl:function name="eo:is-self-call" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="$base = concat('Φ.', $name) or starts-with($base, concat('Φ.', $name, '.')) or $base = concat('ξ.ρ.', $name) or starts-with($base, concat('ξ.ρ.', $name, '.')) or $base = concat('ξ.', $name) or starts-with($base, concat('ξ.', $name, '.'))"/> </xsl:function> <!-- TRUE when the @base is a dispatch on a self-call, i.e. the self-call is the receiver and a method is dispatched on it. --> <xsl:function name="eo:is-self-dispatch" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="starts-with($base, concat('Φ.', $name, '.')) or starts-with($base, concat('ξ.ρ.', $name, '.')) or starts-with($base, concat('ξ.', $name, '.'))"/> </xsl:function> <!-- TRUE when the @base is a self-call in a tail position: the plain call of the object, with no method dispatched on it. A dispatch on the self-call is never a tail call, because the receiver is evaluated, not the call. --> <xsl:function name="eo:is-self-tail" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="$base = concat('Φ.', $name) or $base = concat('ξ.ρ.', $name) or $base = concat('ξ.', $name)"/> </xsl:function> <!-- A nested formation that calls itself has its recursion turned into a Java loop, one copy of the object per step instead of one Java stack block, but only when the compiler recognises the shape. When it does not, the program still runs, only deeper and slower, and nothing says so at the call site. We say it here. --> <xsl:template match="/"> <defects> <xsl:for-each select="//o[eo:abstract(.) and @name and not(contains(@name, '🌵')) and o[@name='φ']]"> <xsl:variable name="name" select="string(@name)"/> <xsl:variable name="root" select="o[@name='φ']"/> <xsl:variable name="calls" select=".//o[eo:is-self-call(string(@base), $name)]"/> <xsl:variable name="loops" select="($root | $root//o)[eo:is-self-tail(string(@base), $name) and eo:tail(., $root)]"/> <xsl:if test="exists($calls) and empty($loops)"> <defect> <xsl:variable name="line" select="eo:lineno($calls[1]/@line)"/> <xsl:attribute name="line"> <xsl:value-of select="$line"/> </xsl:attribute> <xsl:if test="$line = '0'"> <xsl:attribute name="context"> <xsl:value-of select="eo:defect-context(.)"/> </xsl:attribute> </xsl:if> <xsl:attribute name="severity">warning</xsl:attribute> <xsl:attribute name="experimental">true</xsl:attribute> <xsl:text>The recursion in </xsl:text> <xsl:value-of select="eo:escape(@name)"/> <xsl:text> cannot be turned into a loop, </xsl:text> <xsl:choose> <xsl:when test="o[@name='λ']"> <xsl:text>the formation is an atom</xsl:text> </xsl:when> <xsl:when test=".//o[contains(@base, 'φ')]"> <xsl:text>its body reads its own φ</xsl:text> </xsl:when> <xsl:when test="$calls[eo:is-self-dispatch(string(@base), $name)]"> <xsl:text>the self-call is the receiver of a dispatch</xsl:text> </xsl:when> <xsl:otherwise> <xsl:text>no self-call sits in a tail position</xsl:text> </xsl:otherwise> </xsl:choose> </defect> </xsl:if> </xsl:for-each> </defects> </xsl:template>
src/main/resources/org/eolang/lints/design/unoptimizable-recursion.xsl@evgeny113778529+gemshrine@users.noreply.github.com1474132160DEV1321-8d5877d746-133
Name the shapes this lint still misses. The compiler also leaves the recursion alone when the self-call is spelled "Phi.name" instead of "^.name", when the formation is reached other than by a plain application, as a decoratee or as the receiver of a dispatch, when an attribute holding a self-call is read from outside the formation, as in "range", and when two formations call each other. Each of those is syntactic, so each can be found here and reported with a reason of its own, the way the four below are. --> <!-- TRUE when the @base is a self-call of the object with the given name, in any of the three forms the parser emits: the plain name resolves to "Phi.<name>", the "^" form to "xi.rho.<name>", and the "$" form to "xi.<name>". A dispatch on the self-call is also a self-call. --> <xsl:function name="eo:is-self-call" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="$base = concat('Φ.', $name) or starts-with($base, concat('Φ.', $name, '.')) or $base = concat('ξ.ρ.', $name) or starts-with($base, concat('ξ.ρ.', $name, '.')) or $base = concat('ξ.', $name) or starts-with($base, concat('ξ.', $name, '.'))"/> </xsl:function> <!-- TRUE when the @base is a dispatch on a self-call, i.e. the self-call is the receiver and a method is dispatched on it. --> <xsl:function name="eo:is-self-dispatch" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="starts-with($base, concat('Φ.', $name, '.')) or starts-with($base, concat('ξ.ρ.', $name, '.')) or starts-with($base, concat('ξ.', $name, '.'))"/> </xsl:function> <!-- TRUE when the @base is a self-call in a tail position: the plain call of the object, with no method dispatched on it. A dispatch on the self-call is never a tail call, because the receiver is evaluated, not the call. --> <xsl:function name="eo:is-self-tail" as="xs:boolean"> <xsl:param name="base" as="xs:string"/> <xsl:param name="name" as="xs:string"/> <xsl:sequence select="$base = concat('Φ.', $name) or $base = concat('ξ.ρ.', $name) or $base = concat('ξ.', $name)"/> </xsl:function> <!-- A nested formation that calls itself has its recursion turned into a Java loop, one copy of the object per step instead of one Java stack block, but only when the compiler recognises the shape. When it does not, the program still runs, only deeper and slower, and nothing says so at the call site. We say it here. --> <xsl:template match="/"> <defects> <xsl:for-each select="//o[eo:abstract(.) and @name and not(contains(@name, '🌵')) and o[@name='φ']]"> <xsl:variable name="name" select="string(@name)"/> <xsl:variable name="root" select="o[@name='φ']"/> <xsl:variable name="calls" select=".//o[eo:is-self-call(string(@base), $name) and not(ancestor::o[eo:test-name(@name)])]"/> <xsl:variable name="loops" select="($root | $root//o)[eo:is-self-tail(string(@base), $name) and eo:tail(., $root)]"/> <xsl:if test="exists($calls) and empty($loops)"> <defect> <xsl:variable name="line" select="eo:lineno($calls[1]/@line)"/> <xsl:attribute name="line"> <xsl:value-of select="$line"/> </xsl:attribute> <xsl:if test="$line = '0'"> <xsl:attribute name="context"> <xsl:value-of select="eo:defect-context(.)"/> </xsl:attribute> </xsl:if> <xsl:attribute name="severity">warning</xsl:attribute> <xsl:attribute name="experimental">true</xsl:attribute> <xsl:text>The recursion in </xsl:text> <xsl:value-of select="eo:escape(@name)"/> <xsl:text> cannot be turned into a loop, </xsl:text> <xsl:choose> <xsl:when test="o[@name='λ']"> <xsl:text>the formation is an atom</xsl:text> </xsl:when> <xsl:when test=".//o[contains(@base, 'φ')]"> <xsl:text>its body reads its own φ</xsl:text> </xsl:when> <xsl:when test="$calls[eo:is-self-dispatch(string(@base), $name)]"> <xsl:text>the self-call is the receiver of a dispatch</xsl:text> </xsl:when> <xsl:otherwise> <xsl:text>no self-call sits in a tail position</xsl:text> </xsl:otherwise> </xsl:choose> </defect> </xsl:if> </xsl:for-each> </defects> </xsl:template>
src/main/resources/org/eolang/lints/design/unoptimizable-recursion.xslEvgeny113778529+gemshrine@users.noreply.github.com