RFR: JDK-8261079: Fix support for @hidden in classes and interfaces

classic Classic list List threaded Threaded
13 messages Options
Reply | Threaded
Open this post in threaded view
|

RFR: JDK-8261079: Fix support for @hidden in classes and interfaces

Hannes Wallnöfer
This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.

The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)

In `Utils` the most important change are:

 - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
 - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
 - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
 
In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.

Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

-------------

Commit messages:
 - JDK-8261079: Finish tests and small fixes
 - JDK-8261079: Fix support for @hidden in classes and interfaces

Changes: https://git.openjdk.java.net/jdk/pull/2406/files
 Webrev: https://webrevs.openjdk.java.net/?repo=jdk&pr=2406&range=00
  Issue: https://bugs.openjdk.java.net/browse/JDK-8261079
  Stats: 430 lines in 16 files changed: 303 ins; 35 del; 92 mod
  Patch: https://git.openjdk.java.net/jdk/pull/2406.diff
  Fetch: git fetch https://git.openjdk.java.net/jdk pull/2406/head:pull/2406

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces

Hannes Wallnöfer
On Thu, 4 Feb 2021 13:18:09 GMT, Hannes Wallnöfer <[hidden email]> wrote:

> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

Since I changed the code for handling method overrides in `VisibleMemberTable` I compared the generated documentation for current JDK 17 with and without this patch. There were no changes in the generated documentation.

-------------

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces

Jonathan Gibbons-2
In reply to this post by Hannes Wallnöfer
On Thu, 4 Feb 2021 13:18:09 GMT, Hannes Wallnöfer <[hidden email]> wrote:

> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

Two primary areas:

1. I think the changes to Utils to determine if a tag is hidden can be improved/simplified
2. I'm trying to understand the changes to `VisibleMemberTable`

src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java line 2803:

> 2801:             return true;
> 2802:         }
> 2803:         // Run doclint on non-incuded members of included type elements.

typo `incuded`

src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java line 2731:

> 2729:                 if (shouldRunDocLint(element)) {
> 2730:                     configuration.runDocLint(path);
> 2731:                 }

I'm disappointed there is so much disruption to the code because of the enhanced treatment of `@hidden`.Maybe it's necessary, but I was hoping/expecting that we could add a separate code path for the specific purpose of seeing if a non-selected(?) class has a `@hidden` tag.

For example, leave all the code for block tags and doc comment tree alone unchanged, and then provide `isHidden(Element)`  by just using `getDocCommentInfo`, which gives cached access to the `DocCommentTree` then scan the block tags for a `HIDDEN` tree.

src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/VisibleMemberTable.java line 261:

> 259:         OverridingMethodInfo found = overriddenMethodTable.get(e);
> 260:         if (found != null && found.simpleOverride) {
> 261:             return found.overridden;

changing from `overrider` to `overridden` seems like a pretty big change, and not just a terminology cleanup.

Is this related to the change you described in the introduction?

-------------

Changes requested by jjg (Reviewer).

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces

Jonathan Gibbons-2
In reply to this post by Hannes Wallnöfer
On Thu, 4 Feb 2021 13:18:09 GMT, Hannes Wallnöfer <[hidden email]> wrote:

> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java line 1567:

> 1565:         // prevent needless tests on elements which are neither included nor selected.
> 1566:         // Non-included members may still be visible via "transclusion" from undocumented enclusure
> 1567:         if (!isIncluded(e) && !configuration.docEnv.isSelected(e)) {

This comment applies to the whole of this method body.

I think the `@hidden` (or `@treatAsprivate`) tag is sufficiently special that it should be handled separately, especially in the cases where the containing comment would not otherwise be read, because the element is not included/selected. See other/earlier comments about avoiding `getDocComment` and going to the underlying `getDocCommentInfo`, which will (should?) completely bypass `getDocComment` and (importantly) the use of doclint.

-------------

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v2]

Hannes Wallnöfer
In reply to this post by Hannes Wallnöfer
> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

Hannes Wallnöfer has updated the pull request incrementally with one additional commit since the last revision:

  JDK-8261079: Updates to review comments
   - Use separate unchecked/uncached code path when checking for @hidden tag on non-incuded elements
   - Rename OverridingMethodInfo to OverriddenMethodInfo to better reflect its purpose

-------------

Changes:
  - all: https://git.openjdk.java.net/jdk/pull/2406/files
  - new: https://git.openjdk.java.net/jdk/pull/2406/files/26ec60cd..cd194c6b

Webrevs:
 - full: https://webrevs.openjdk.java.net/?repo=jdk&pr=2406&range=01
 - incr: https://webrevs.openjdk.java.net/?repo=jdk&pr=2406&range=00-01

  Stats: 49 lines in 2 files changed: 18 ins; 15 del; 16 mod
  Patch: https://git.openjdk.java.net/jdk/pull/2406.diff
  Fetch: git fetch https://git.openjdk.java.net/jdk pull/2406/head:pull/2406

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v3]

Hannes Wallnöfer
In reply to this post by Hannes Wallnöfer
> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

Hannes Wallnöfer has updated the pull request with a new target base due to a merge or a rebase. The pull request now contains four commits:

 - Merge master
 - JDK-8261079: Updates to review comments
    - Use separate unchecked/uncached code path when checking for @hidden tag on non-incuded elements
    - Rename OverridingMethodInfo to OverriddenMethodInfo to better reflect its purpose
 - JDK-8261079: Finish tests and small fixes
 - JDK-8261079: Fix support for @hidden in classes and interfaces

-------------

Changes: https://git.openjdk.java.net/jdk/pull/2406/files
 Webrev: https://webrevs.openjdk.java.net/?repo=jdk&pr=2406&range=02
  Stats: 435 lines in 16 files changed: 303 ins; 32 del; 100 mod
  Patch: https://git.openjdk.java.net/jdk/pull/2406.diff
  Fetch: git fetch https://git.openjdk.java.net/jdk pull/2406/head:pull/2406

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v3]

Hannes Wallnöfer
In reply to this post by Jonathan Gibbons-2
On Thu, 11 Feb 2021 00:32:07 GMT, Jonathan Gibbons <[hidden email]> wrote:

>> Hannes Wallnöfer has updated the pull request with a new target base due to a merge or a rebase. The pull request now contains four commits:
>>
>>  - Merge master
>>  - JDK-8261079: Updates to review comments
>>     - Use separate unchecked/uncached code path when checking for @hidden tag on non-incuded elements
>>     - Rename OverridingMethodInfo to OverriddenMethodInfo to better reflect its purpose
>>  - JDK-8261079: Finish tests and small fixes
>>  - JDK-8261079: Fix support for @hidden in classes and interfaces
>
> Two primary areas:
>
> 1. I think the changes to Utils to determine if a tag is hidden can be improved/simplified
> 2. I'm trying to understand the changes to `VisibleMemberTable`

Thanks for the review, Jon!

I pushed a new commit that should address your concerns. For the lookup of `@hidden` tags in non-included elements I added a new `hasBlockTagUnchecked` method that avoids caching and doclint checking by using  `getDocCommentInfo` as you suggested. Note that this isn't used for the javafx "treatAsPrivate" tag as changing the semantics of an undocumented/internal tag didn't seem like a good idea on second thought.

Regarding the renaming of `overrider` to `overridden`: the old name was a misnomer, the new name actually reflects the meaning of the field as it contains the overridden method, not the overriding one. I actually went the whole way and renamed the nested class as well, from `OverridingMethodInfo` to `OverriddenMethodInfo`.

-------------

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v4]

Hannes Wallnöfer
In reply to this post by Hannes Wallnöfer
> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

Hannes Wallnöfer has updated the pull request incrementally with one additional commit since the last revision:

  JDK-8261079: Remove unnecessary isSelected check

-------------

Changes:
  - all: https://git.openjdk.java.net/jdk/pull/2406/files
  - new: https://git.openjdk.java.net/jdk/pull/2406/files/9760a32d..66e9b54a

Webrevs:
 - full: https://webrevs.openjdk.java.net/?repo=jdk&pr=2406&range=03
 - incr: https://webrevs.openjdk.java.net/?repo=jdk&pr=2406&range=02-03

  Stats: 5 lines in 1 file changed: 1 ins; 2 del; 2 mod
  Patch: https://git.openjdk.java.net/jdk/pull/2406.diff
  Fetch: git fetch https://git.openjdk.java.net/jdk pull/2406/head:pull/2406

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v3]

Jonathan Gibbons
In reply to this post by Hannes Wallnöfer

On 2/11/21 4:10 AM, Hannes Wallnöfer wrote:
> Thanks for the review, Jon!
>
> I pushed a new commit that should address your concerns. For the lookup of `@hidden` tags in non-included elements I added a new `hasBlockTagUnchecked` method that avoids caching and doclint checking by using  `getDocCommentInfo` as you suggested. Note that this isn't used for the javafx "treatAsPrivate" tag as changing the semantics of an undocumented/internal tag didn't seem like a good idea on second thought.

I agree that there is no need and that we should not change the
operation of the older `treatAsPrivate` flag.


>
> Regarding the renaming of `overrider` to `overridden`: the old name was a misnomer, the new name actually reflects the meaning of the field as it contains the overridden method, not the overriding one. I actually went the whole way and renamed the nested class as well, from `OverridingMethodInfo` to `OverriddenMethodInfo`.

Understood.

(For my own satisfaction, I may go back and look at the old code, to
better understand the provenance of the name. That is independent of
this review.)


-- Jon


Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v3]

Jonathan Gibbons
In reply to this post by Hannes Wallnöfer

On 2/11/21 4:10 AM, Hannes Wallnöfer wrote:
>   - JDK-8261079: Updates to review comments
>      - Use separate unchecked/uncached code path when checking for @hidden tag on non-incuded elements


I think you'll find that if you dig deep enough, it is not so much
"uncached" as "less cached"!

The comments read from files are cached deep down in `jdk.compiler` 
(JCTrees:533, DocCommentTable) ... the additional level of caching in
javadoc is to support caching of synthetic comments, such as for the
mandated methods on enum and record classes.

-- Jon

Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v4]

Jonathan Gibbons-2
In reply to this post by Hannes Wallnöfer
On Thu, 11 Feb 2021 12:37:55 GMT, Hannes Wallnöfer <[hidden email]> wrote:

>> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>>
>> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>>
>> In `Utils` the most important change are:
>>
>>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>>  
>> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>>
>> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.
>
> Hannes Wallnöfer has updated the pull request incrementally with one additional commit since the last revision:
>
>   JDK-8261079: Remove unnecessary isSelected check

Marked as reviewed by jjg (Reviewer).

-------------

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Re: RFR: JDK-8261079: Fix support for @hidden in classes and interfaces [v5]

Hannes Wallnöfer
In reply to this post by Hannes Wallnöfer
> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

Hannes Wallnöfer has updated the pull request with a new target base due to a merge or a rebase. The pull request now contains six commits:

 - Merge master
 - JDK-8261079: Remove unnecessary isSelected check
 - Merge master
 - JDK-8261079: Updates to review comments
    - Use separate unchecked/uncached code path when checking for @hidden tag on non-incuded elements
    - Rename OverridingMethodInfo to OverriddenMethodInfo to better reflect its purpose
 - JDK-8261079: Finish tests and small fixes
 - JDK-8261079: Fix support for @hidden in classes and interfaces

-------------

Changes: https://git.openjdk.java.net/jdk/pull/2406/files
 Webrev: https://webrevs.openjdk.java.net/?repo=jdk&pr=2406&range=04
  Stats: 435 lines in 16 files changed: 303 ins; 32 del; 100 mod
  Patch: https://git.openjdk.java.net/jdk/pull/2406.diff
  Fetch: git fetch https://git.openjdk.java.net/jdk pull/2406/head:pull/2406

PR: https://git.openjdk.java.net/jdk/pull/2406
Reply | Threaded
Open this post in threaded view
|

Integrated: JDK-8261079: Fix support for @hidden in classes and interfaces

Hannes Wallnöfer
In reply to this post by Hannes Wallnöfer
On Thu, 4 Feb 2021 13:18:09 GMT, Hannes Wallnöfer <[hidden email]> wrote:

> This change improves support for the `@hidden` tag to suppress documentation for specific elements, especially in the context of classes, interfaces and inheritance/method overriding.
>
> The important changes are in `Utils` and in `VisibleMemberTable`. (There is also a number of non-related small code cleanup changes, sorry about that, I know it makes review a bit harder but I couldn't resist.)
>
> In `Utils` the most important change are:
>
>  - Consider types as "undocumented enclosures" if they are marked with a `@hidden` tag
>  - Check for `@hidden` tags even in non-included elements as they may be included via undocumented enclosures
>  - To counter the above change, only run doclint on elements that are either included or contained in an included type, as we don't want to report warnings or errors for non-included code.
>  
> In `VisibleMemberTable` there is a subtle change to not consider an overriding method as a "simple override" if the overridden method is hidden or otherwise invisible but in turn is a non-simple override of a method further up the inheritance chain. This resulted in methods which should have been documented as declared locally to be documented as declared in supertypes. I also did a bit of renaming in `VisibleMemberTable` to make the purpose of things a bit clearer.
>
> Other than that, most of the changes consist of added calls to `utils.hasHiddenTag(Element)`, usually with the purpose of not generating links to things that are not there.

This pull request has now been integrated.

Changeset: 3210095a
Author:    Hannes Wallnöfer <[hidden email]>
URL:       https://git.openjdk.java.net/jdk/commit/3210095a
Stats:     435 lines in 16 files changed: 303 ins; 32 del; 100 mod

8261079: Fix support for @hidden in classes and interfaces

Reviewed-by: jjg

-------------

PR: https://git.openjdk.java.net/jdk/pull/2406