Attachment #105622 for bug #194969

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 194969
Collapse All | Expand All

Lines 46-51 Link Here

(-)a/java.editor/src/org/netbeans/modules/editor/java/JavaCompletionDoc.java (+5 lines)
46		46
47	import java.net.URL;	47	import java.net.URL;
48	import java.util.concurrent.Callable;	48	import java.util.concurrent.Callable;
		49	import java.util.concurrent.Future;
49	import javax.lang.model.element.Element;	50	import javax.lang.model.element.Element;
50	import javax.swing.Action;	51	import javax.swing.Action;
51	import org.netbeans.api.java.source.CompilationController;	52	import org.netbeans.api.java.source.CompilationController;
Lines 77-82 Link Here
77	return elementJavadoc.getText();	78	return elementJavadoc.getText();
78	}	79	}
79		80
		81	public Future<String> getFutureText() {
		82	return elementJavadoc.getFutureText();
		83	}
		84
80	public Action getGotoSourceAction() {	85	public Action getGotoSourceAction() {
81	return elementJavadoc.getGotoSourceAction();	86	return elementJavadoc.getGotoSourceAction();
82	}	87	}

Lines 51-56 Link Here

(-)a/java.editor/src/org/netbeans/modules/editor/java/JavaCompletionProvider.java (-1 / +13 lines)
51	import java.util.*;	51	import java.util.*;
52	import java.util.concurrent.Callable;	52	import java.util.concurrent.Callable;
53	import java.util.concurrent.Future;	53	import java.util.concurrent.Future;
		54	import java.util.concurrent.TimeUnit;
		55	import java.util.concurrent.TimeoutException;
54	import java.util.logging.Logger;	56	import java.util.logging.Logger;
55	import java.util.logging.Level;	57	import java.util.logging.Level;
56	import javax.lang.model.SourceVersion;	58	import javax.lang.model.SourceVersion;
Lines 303-310 Link Here
303	if (toolTip != null && toolTip.hasData())	305	if (toolTip != null && toolTip.hasData())
304	resultSet.setToolTip(toolTip);	306	resultSet.setToolTip(toolTip);
305	} else if (queryType == DOCUMENTATION_QUERY_TYPE) {	307	} else if (queryType == DOCUMENTATION_QUERY_TYPE) {
306	if (documentation != null)	308	if (documentation instanceof JavaCompletionDoc) {
		309	while (!isTaskCancelled()) {
		310	try {
		311	((JavaCompletionDoc)documentation).getFutureText().get(250, TimeUnit.MILLISECONDS);
		312	resultSet.setDocumentation(documentation);
		313	break;
		314	} catch (TimeoutException timeOut) {/retry/}
		315	}
		316
		317	} else if (documentation != null) {
307	resultSet.setDocumentation(documentation);	318	resultSet.setDocumentation(documentation);
		319	}
308	}	320	}
309	if (anchorOffset > -1)	321	if (anchorOffset > -1)
310	resultSet.setAnchorOffset(anchorOffset);	322	resultSet.setAnchorOffset(anchorOffset);




 */
package org.netbeans.api.java.source.ui;

import com.sun.source.util.Trees;
import java.awt.event.ActionEvent;
import java.io.IOException;
import java.lang.reflect.Modifier;
import java.net.URI;
import java.net.URL;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;

import javax.swing.Action;
import com.sun.javadoc.*;
import com.sun.javadoc.AnnotationDesc.ElementValuePair;
import com.sun.source.util.Trees;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import org.netbeans.api.java.source.ClasspathInfo;
import org.netbeans.api.java.source.CompilationController;
import org.netbeans.api.java.source.CompilationInfo;

import org.netbeans.api.java.source.JavaSource.Phase;
import org.netbeans.api.java.source.SourceUtils;
import org.netbeans.api.java.source.Task;
import org.netbeans.modules.java.preprocessorbridge.api.JavaSourceUtil;
import org.netbeans.modules.java.source.JavaSourceAccessor;
import org.netbeans.modules.java.source.JavadocHelper;
import org.netbeans.modules.java.source.usages.Pair;
import org.netbeans.modules.parsing.spi.ParseException;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStateInvalidException;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.xml.XMLUtil;

/** Utility class for viewing Javadoc comments as HTML.

    
    private static final String API = "/api";                                   //NOI18N
    private static final Set<String> LANGS;

    private static final RequestProcessor RP = new RequestProcessor(ElementJavadoc.class);
    
    static {
        Locale[] availableLocales = Locale.getAvailableLocales();

    }

    private ClasspathInfo cpInfo;
    private ElementUtilities eu;
    private Trees trees;
    //private Doc doc;
    private Future<String> content;
    private Hashtable<String, ElementHandle<? extends Element>> links = new Hashtable<String, ElementHandle<? extends Element>>();
    private int linkCounter = 0;
    private URL docURL = null;

     * @return HTML text of the javadoc
     */
    public String getText() {
        try {
            return content.get();
        } catch (InterruptedException ex) {
            return null;
        } catch (ExecutionException ex) {
            return null;
        }
    }

    public Future<String> getFutureText() {
        return content;
    }


    }
    
    private ElementJavadoc(CompilationInfo compilationInfo, Element element, URL url, final Callable<Boolean> cancel) {
        Pair<Trees,ElementUtilities> context = Pair.of(compilationInfo.getTrees(), compilationInfo.getElementUtilities());
        this.eu = compilationInfo.getElementUtilities();
        this.cpInfo = compilationInfo.getClasspathInfo();
        Doc doc = context.second.javaDocFor(element);
        boolean localized = false;
        StringBuilder content = new StringBuilder();
        JavadocHelper.TextStream page = null;

                }
            }
        }
        try {
            //Optimisitic no http
            this.content = prepareContent(content, doc,localized, page, cancel, true, context);
        } catch (RemoteJavadocException re) {
            final FileObject fo = compilationInfo.getFileObject();
            final ElementHandle<? extends Element> handle = ElementHandle.create(element);
            final StringBuilder contentFin = content;
            final boolean localizedFin = localized;
            this.content = new FutureTask<String>(new Callable<String>(){
                @Override
                public String call() throws Exception {
                    final JavaSourceUtil.Handle ch = JavaSourceUtil.createControllerHandle(fo, null);
                    final CompilationController c = (CompilationController) ch.getCompilationController();
                    c.toPhase(Phase.RESOLVED);
                    final Element element = handle.resolve(c);
                    Pair<Trees,ElementUtilities> context = Pair.of(c.getTrees(), c.getElementUtilities());
                    Doc doc = context.second.javaDocFor(element);
                    JavadocHelper.TextStream page = JavadocHelper.getJavadoc(element, cancel);
                    return prepareContent(contentFin, doc,localizedFin, page, cancel, false, context).get();
                }
            });
            RP.post((Runnable)this.content);
        }
    }
    
    private ElementJavadoc(URL url) {

           
    /**
     * Creates javadoc content
     * @header header of the generated HTML
     * @param eu element utilities to find out elements
     * @param doc javac javadoc model
     * @param useJavadoc preffer javadoc to sources
     * @return Javadoc content
     */
    private Future<String> prepareContent(
            final StringBuilder header,
            final Doc doc,
            final boolean useJavadoc,
            final JavadocHelper.TextStream page,
            final Callable<Boolean> cancel,
            final boolean sync, Pair<Trees,ElementUtilities> ctx) throws RemoteJavadocException {


        final StringBuilder sb = new StringBuilder(header);
        if (doc != null) {
            if (doc instanceof ProgramElementDoc) {
                sb.append(getContainingClassOrPackageHeader((ProgramElementDoc)doc, ctx));
            }
            if (doc.isMethod() || doc.isConstructor() || doc.isAnnotationTypeElement()) {
                sb.append(getMethodHeader((ExecutableMemberDoc)doc, ctx));
            } else if (doc.isField() || doc.isEnumConstant()) {
                sb.append(getFieldHeader((FieldDoc)doc, ctx));
            } else if (doc.isClass() || doc.isInterface() || doc.isAnnotationType()) {
                sb.append(getClassHeader((ClassDoc)doc, ctx));
            } else if (doc instanceof PackageDoc) {
                sb.append(getPackageHeader((PackageDoc)doc, ctx));
            }
            sb.append("<p>"); //NOI18N
            if (!useJavadoc) {

                            inheritedReturnTags != null && inheritedReturnTags.isEmpty() ||
                            paramPos != null && !paramPos.isEmpty() ||
                            throwsTypes != null && !throwsTypes.isEmpty()) {
                            String s = inheritedDocFor(mdoc, mdoc.containingClass(), inheritedTags, inheritedReturnTags,
                            paramPos, inheritedParamTags, inheritedParamInlineTags,
                            throwsTypes, inheritedThrowsTags, inheritedThrowsInlineTags, cancel, sync, ctx);
                            if (s != null) {
                                sb.append(s);
                                sb.append("</p>"); //NOI18N
                                return new Now(sb.toString());
                            }
                    }
                    if (inheritedTags != null && !inheritedTags.isEmpty()) {
                        if (inlineTags.length == 0) {

                        }
                    }
                    if (inlineTags.length > 0 || doc.tags().length > 0) {
                        sb.append(getDeprecatedTag(doc, ctx));
                        sb.append(inlineTags(doc, inlineTags, ctx));
                        sb.append("</p><p>"); //NOI18N
                        sb.append(getMethodTags(mdoc, returnTags, paramTags,
                                throwsTags, throwsInlineTags, ctx));
                        sb.append("</p>"); //NOI18N
                        return new Now(sb.toString());
                    }
                } else {
                    if (inlineTags.length > 0 || doc.tags().length > 0) {
                        sb.append(getDeprecatedTag(doc, ctx));
                        sb.append(inlineTags(doc, inlineTags, ctx));
                        sb.append("</p><p>"); //NOI18N
                        sb.append(getTags(doc, ctx));
                        sb.append("</p>"); //NOI18N
                        return new Now(sb.toString());
                    }
                }
            }

            final Callable<String> call = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    String jdText = page != null ? HTMLJavadocParser.getJavadocText(page, false) : docURL != null ? HTMLJavadocParser.getJavadocText(docURL, false) : null;
                    if (jdText != null)
                        sb.append(jdText);
                    else
                        sb.append(NbBundle.getMessage(ElementJavadoc.class, "javadoc_content_not_found")); //NOI18N
                    sb.append("</p>"); //NOI18N
                    return sb.toString();
                }
            };
            final FutureTask<String> task = new FutureTask<String>(call);
            if (sync) {
                RP.post(task);
            } else {
                task.run();
            }
            return task;
        }
        sb.append(NbBundle.getMessage(ElementJavadoc.class, "javadoc_content_not_found")); //NOI18N
        return new Now (sb.toString());
    }
    
    private CharSequence getContainingClassOrPackageHeader(ProgramElementDoc peDoc, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        ClassDoc cls = peDoc.containingClass();
        if (cls != null) {
            Element e = ctx.second.elementFor(cls);
            if (e != null) {
                switch(e.getEnclosingElement().getKind()) {
                    case ANNOTATION_TYPE:

            PackageDoc pkg = peDoc.containingPackage();
            if (pkg != null) {
                sb.append("<font size='+0'><b>"); //NOI18N
                createLink(sb, ctx.second.elementFor(pkg), makeNameLineBreakable(pkg.name()));
                sb.append("</b></font>"); //NOI18N)
            }
        }

        return name.replace(".", /* ZERO WIDTH SPACE */".&#x200B;");
    }
    
    private CharSequence getMethodHeader(ExecutableMemberDoc mdoc, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        sb.append("<p><tt>"); //NOI18N
        sb.append(getAnnotations(mdoc.annotations(), ctx));
        int len = sb.length();
        sb.append(Modifier.toString(mdoc.modifierSpecifier() &~ Modifier.NATIVE));
        len = sb.length() - len;

            }
            sb.append("&lt;"); //NOI18N
            for (int i = 0; i < tvars.length; i++) {
                len += appendType(sb, tvars[i], false, true, false, ctx);
                if (i < tvars.length - 1) {
                    sb.append(","); //NOI18N
                    len++;

                sb.append(' '); //NOI18N
                len++;
            }
            len += appendType(sb, ((MethodDoc)mdoc).returnType(), false, false, false, ctx);
        }
        String name = mdoc.name();
        len += name.length();

            len++;
            Parameter[] params = mdoc.parameters();
            for(int i = 0; i < params.length; i++) {
                sb.append(getAnnotations(params[i].annotations(), ctx));
                boolean varArg = i == params.length - 1 && mdoc.isVarArgs();
                appendType(sb, params[i].type(), varArg, false, false, ctx);
                sb.append(' ').append(params[i].name()); //NOI18N
                String dim = params[i].type().dimension();
                if (dim.length() > 0) {

        if (exs.length > 0) {
            sb.append(" throws "); //NOI18N
            for (int i = 0; i < exs.length; i++) {
                appendType(sb, exs[i], false, false, false, ctx);
                if (i < exs.length - 1)
                    sb.append(", "); //NOI18N
            }

        return sb;
    }
    
    private CharSequence getFieldHeader(FieldDoc fdoc, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        sb.append("<p><tt>"); //NOI18N
        sb.append(getAnnotations(fdoc.annotations(), ctx));
        int len = sb.length();
        sb.append(fdoc.modifiers());
        len = sb.length() - len;
        if (len > 0)
            sb.append(' '); //NOI18N
        appendType(sb, fdoc.type(), false, false, false, ctx);
        sb.append(" <b>").append(fdoc.name()).append("</b>"); //NOI18N
        sb.append("</tt></p>"); //NOI18N
        return sb;
    }
    
    private CharSequence getClassHeader(ClassDoc cdoc, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        sb.append("<p><tt>"); //NOI18N
        sb.append(getAnnotations(cdoc.annotations(), ctx));
        int mods = cdoc.modifierSpecifier() & ~Modifier.INTERFACE;
        if (cdoc.isEnum())
            mods &= ~Modifier.FINAL;

        if (tvars.length > 0) {
            sb.append("&lt;"); //NOI18N
            for (int i = 0; i < tvars.length; i++) {
                appendType(sb, tvars[i], false, true, false, ctx);
                if (i < tvars.length - 1)
                    sb.append(","); //NOI18N
            }

                Type supercls = cdoc.superclassType();
                if (supercls != null) {
                    sb.append(" extends "); //NOI18N
                    appendType(sb, supercls, false, false, false, ctx);
                }
            }
            Type[] ifaces = cdoc.interfaceTypes();
            if (ifaces.length > 0) {
                sb.append(cdoc.isInterface() ? " extends " : " implements "); //NOI18N
                for (int i = 0; i < ifaces.length; i++) {
                    appendType(sb, ifaces[i], false, false, false, ctx);
                    if (i < ifaces.length - 1)
                        sb.append(", "); //NOI18N
                }

        return sb;
    }
    
    private CharSequence getPackageHeader(PackageDoc pdoc, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        sb.append("<p><tt>"); //NOI18N
        sb.append(getAnnotations(pdoc.annotations(), ctx));
        sb.append("package <b>").append(pdoc.name()).append("</b>"); //NOI18N
        sb.append("</tt></p>"); //NOI18N
        return sb;
    }
    
    private CharSequence getAnnotations(AnnotationDesc[] annotations, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        for (AnnotationDesc annotationDesc : annotations) {
            AnnotationTypeDoc annotationType = annotationDesc.annotationType();
            if (annotationType != null && isDocumented(annotationType)) {
                appendType(sb, annotationType, false, false, true, ctx);
                ElementValuePair[] pairs = annotationDesc.elementValues();
                if (pairs.length > 0) {
                    sb.append('('); //NOI18N
                    for (int i = 0; i < pairs.length; i++) {
                        AnnotationTypeElementDoc ated = pairs[i].element();
                        createLink(sb, ctx.second.elementFor(ated), ated.name());
                        sb.append('='); //NOI18N
                        appendAnnotationValue(sb, pairs[i].value(), ctx);
                        if (i < pairs.length - 1)
                            sb.append(","); //NOI18N
                    }

        return false;
    }
    
    private void appendAnnotationValue(StringBuilder sb, AnnotationValue av, Pair<Trees,ElementUtilities> ctx) {
        Object value = av.value();
        if (value instanceof AnnotationValue[]) {
            int length = ((AnnotationValue[])value).length;
            if (length > 1)
                sb.append('{'); //NOI18N
            for(int i = 0; i < ((AnnotationValue[])value).length; i++) {
                appendAnnotationValue(sb, ((AnnotationValue[])value)[i], ctx);
                if (i < ((AnnotationValue[])value).length - 1)
                    sb.append(","); //NOI18N
            }
            if (length > 1)
                sb.append('}'); //NOI18N
        } else if (value instanceof Doc) {
            createLink(sb, ctx.second.elementFor((Doc)value), ((Doc)value).name());
        } else {
            sb.append(value.toString());
        }
    } 
    
    private CharSequence getMethodTags(MethodDoc doc, Tag[] returnTags, Map<Integer, List<Tag>> paramInlineTags,
            List<ThrowsTag> throwsTags, Map<String, List<Tag>> throwsInlineTags, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder ret = new StringBuilder();
        if (returnTags.length > 0) {
            ret.append(inlineTags(doc, returnTags, ctx));
            ret.append("<br>"); //NOI18N
        }
        StringBuilder par = new StringBuilder();

                List<Tag> tags = paramInlineTags.get(pos);
                Tag[] its = tags.toArray(new Tag[tags.size()]);                
                if (its.length > 0) {
                    CharSequence cs = inlineTags(doc, its, ctx);
                    if (cs.length() > 0) {
                        par.append(" - "); //NOI18N
                        par.append(cs);

                tpar.append("<code>").append(pTag.parameterName()).append("</code>"); //NOI18N
                Tag[] its = pTag.inlineTags();
                if (its.length > 0) {
                    CharSequence cs = inlineTags(doc, its, ctx);
                    if (cs.length() > 0) {
                        tpar.append(" - "); //NOI18N
                        tpar.append(cs);

                thr.append("<code>"); //NOI18N
                Type exType = throwsTag.exceptionType();
                if (exType != null) {
                    createLink(thr, ctx.second.elementFor(exType.asClassDoc()), exType.simpleTypeName());
                } else {
                    thr.append(throwsTag.exceptionName());
                }

                List<Tag> tags = throwsInlineTags.get(exType != null ? exType.qualifiedTypeName() : throwsTag.exceptionName());
                Tag[] its = tags == null ? throwsTag.inlineTags() : tags.toArray(new Tag[tags.size()]);                
                if (its.length > 0) {
                    CharSequence cs = inlineTags(doc, its, ctx);
                    if (cs.length() > 0) {
                        thr.append(" - "); //NOI18N
                        thr.append(cs);

                String label = stag.label();
                if (memberName != null) {
                    if (refClass != null) {
                        createLink(see, ctx.second.elementFor(stag.referencedMember()), "<code>" + (label != null && label.length() > 0 ? label : (refClass.simpleTypeName() + "." + memberName)) + "</code>"); //NOI18N
                    } else {
                        see.append(className);
                        see.append('.'); //NOI18N

                    see.append(", "); //NOI18N
                } else if (className != null) {
                    if (refClass != null) {
                        createLink(see, ctx.second.elementFor(refClass), "<code>" + (label != null && label.length() > 0 ? label : refClass.simpleTypeName()) + "</code>"); //NOI18N
                    } else {
                        see.append(className);
                    }

        return sb;
    }
    
    private CharSequence getTags(Doc doc, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder see = new StringBuilder();
        StringBuilder par = new StringBuilder();
        StringBuilder thr = new StringBuilder();

                Tag[] its = tag.inlineTags();
                if (its.length > 0) {
                    par.append(" - "); //NOI18N
                    par.append(inlineTags(doc, its, ctx));
                }
                par.append("<br>"); //NOI18N
            } else if (THROWS_TAG.equals(tag.kind()) && !doc.isMethod()) {
                thr.append("<code>"); //NOI18N
                Type exType = ((ThrowsTag)tag).exceptionType();
                if (exType != null)
                    createLink(thr, ctx.second.elementFor(exType.asClassDoc()), exType.simpleTypeName());
                else
                    thr.append(((ThrowsTag)tag).exceptionName());
                thr.append("</code>"); //NOI18N
                Tag[] its = tag.inlineTags();
                if (its.length > 0) {
                    thr.append(" - "); //NOI18N
                    thr.append(inlineTags(doc, its, ctx));
                }
                thr.append("<br>"); //NOI18N
            } else if (RETURN_TAG.equals(tag.kind()) && !doc.isMethod()) {
                ret.append(inlineTags(doc, tag.inlineTags(), ctx));
                ret.append("<br>"); //NOI18N
            } else if (SEE_TAG.equals(tag.kind())) {
                SeeTag stag = (SeeTag)tag;

                String label = stag.label();
                if (memberName != null) {
                    if (refClass != null) {
                        createLink(see, ctx.second.elementFor(stag.referencedMember()), "<code>" + (label != null && label.length() > 0 ? label : (refClass.simpleTypeName() + "." + memberName)) + "</code>"); //NOI18N
                    } else {
                        see.append(className);
                        see.append('.'); //NOI18N

                    see.append(", "); //NOI18N
                } else if (className != null) {
                    if (refClass != null) {
                        createLink(see, ctx.second.elementFor(refClass), "<code>" + (label != null && label.length() > 0 ? label : refClass.simpleTypeName()) + "</code>"); //NOI18N
                    } else {
                        see.append(className);
                    }

        return sb;
    }
    
    private CharSequence getDeprecatedTag(Doc doc, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        for (Tag tag : doc.tags()) {
            if (DEPRECATED_TAG.equals(tag.kind())) {
                sb.append("<b>").append(NbBundle.getMessage(ElementJavadoc.class, "JCD-deprecated")).append("</b> <i>").append(inlineTags(doc, tag.inlineTags(),ctx)).append("</i></p><p>"); //NOI18N
                break;
            }
        }
        return sb;
    }
    
    private CharSequence inlineTags(Doc doc, Tag[] tags, Pair<Trees,ElementUtilities> ctx) {
        StringBuilder sb = new StringBuilder();
        for (Tag tag : tags) {
            if (SEE_TAG.equals(tag.kind())) {

                    boolean plain = LINKPLAIN_TAG.equals(stag.name());
                    if (memberName != null) {
                        if (refClass != null) {
                            createLink(sb, ctx.second.elementFor(stag.referencedMember()), (plain ? "" : "<code>") + (label != null && label.length() > 0 ? label : (refClass.simpleTypeName() + "." + memberName)) + (plain ? "" : "</code>")); //NOI18N
                        } else {
                            sb.append(stag.referencedClassName());
                            sb.append('.'); //NOI18N

                        }
                    } else {
                        if (refClass != null) {
                            createLink(sb, ctx.second.elementFor(refClass), (plain ? "" : "<code>") + (label != null && label.length() > 0 ? label : refClass.simpleTypeName()) + (plain ? "" : "</code>")); //NOI18N
                        } else {
                            sb.append(stag.referencedClassName());
                        }

                if (doc.isMethod()) {
                    MethodDoc mdoc = ((MethodDoc)doc).overriddenMethod();
                    if (mdoc != null)
                        sb.append(inlineTags(mdoc, mdoc.inlineTags(),ctx));
                }
            } else if (LITERAL_TAG.equals(tag.kind())) {
                try {

            sb.append(' '); //NOI18N            
    }
    
    private int appendType(StringBuilder sb, Type type, boolean varArg, boolean typeVar, boolean annotation, Pair<Trees,ElementUtilities> ctx) {
        int len = 0;
        WildcardType wt = type.asWildcardType();
        if (wt != null) {

            if (bounds != null && bounds.length > 0) {
                sb.append(" extends "); //NOI18N
                len += 9;
                len += appendType(sb, bounds[0], false, false, false, ctx);
            }
            bounds = wt.superBounds();
            if (bounds != null && bounds.length > 0) {
                sb.append(" super "); //NOI18N
                len += 7;
                len += appendType(sb, bounds[0], false, false, false, ctx);
            }
        } else {
            TypeVariable tv = type.asTypeVariable();

                    sb.append(" extends "); //NOI18N
                    len += 9;
                    for (int i = 0; i < bounds.length; i++) {
                        len += appendType(sb, bounds[i], false, false, false, ctx);
                        if (i < bounds.length - 1) {
                            sb.append(" & "); //NOI18N
                            len += 3;

                String tName = cd != null ? cd.name() : type.simpleTypeName();
                if (cd != null && cd.isAnnotationType() && annotation)
                    tName = "@" + tName; //NOI18N
                len += createLink(sb, ctx.second.elementFor(type.asClassDoc()), tName);
                ParameterizedType pt = type.asParameterizedType();
                if (pt != null) {
                    Type[] targs = pt.typeArguments();
                    if (targs.length > 0) {
                        sb.append("&lt;"); //NOI18N
                        for (int j = 0; j < targs.length; j++) {
                            len += appendType(sb, targs[j], false, false, false, ctx);
                            if (j < targs.length - 1) {
                                sb.append(","); //NOI18N
                                len++;

    private String inheritedDocFor(MethodDoc mdoc, ClassDoc cdoc, List<Tag> inlineTags, List<Tag> returnTags,
            Set<Integer> paramPos, Map<Integer, ParamTag> paramTags, Map<Integer, List<Tag>> paramInlineTags,
            Set<String> throwsTypes, Map<String, ThrowsTag> throwsTags, Map<String, List<Tag>> throwsInlineTags,
            Callable<Boolean> cancel, boolean stopByRemoteJdoc, Pair<Trees,ElementUtilities> ctx) throws RemoteJavadocException {
        JavadocHelper.TextStream inheritedPage = null;
        for (ClassDoc ifaceDoc : cdoc.interfaces()) {
            for (MethodDoc methodDoc : ifaceDoc.methods(false)) {
                if (mdoc.overrides(methodDoc)) {
                    Element e = ctx.second.elementFor(methodDoc);
                    boolean isLocalized = false;
                    if (e != null) {
                        inheritedPage = JavadocHelper.getJavadoc(e, cancel);

                            docURL = inheritedPage.getLocation();
                        }
                        if (!(isLocalized = isLocalized(docURL, e)))
                            ctx.first.getTree(e);
                    }
                    if (!isLocalized) {
                        List<Tag> inheritedInlineTags = null;

                                inheritedParamPos != null && inheritedParamTags != null)
                            inheritedDocFor(mdoc, ifaceDoc, inheritedInlineTags, inheritedReturnTags,
                                    inheritedParamPos, inheritedParamTags, inheritedParamInlineTags,
                                    inheritedThrowsTypes, inheritedThrowsTags, inheritedThrowsInlineTags, cancel, stopByRemoteJdoc, ctx);
                        if (inheritedInlineTags != null && !inheritedInlineTags.isEmpty()) {
                            inlineTags.clear();
                            for (Tag tag : methodDoc.inlineTags()) {

                    (throwsTypes == null || throwsTypes.isEmpty()))
                return null;
        }
        if (stopByRemoteJdoc && isRemote(inheritedPage, docURL)) {
            throw new RemoteJavadocException();
        }
        String jdText = inheritedPage != null ? HTMLJavadocParser.getJavadocText(inheritedPage, false) : docURL != null ? HTMLJavadocParser.getJavadocText(docURL, false) : null;
        if (jdText != null)
            return jdText;
        for (ClassDoc ifaceDoc : cdoc.interfaces()) {
            jdText = inheritedDocFor(mdoc, ifaceDoc, inlineTags, returnTags,
                    paramPos, paramTags, paramInlineTags,
                    throwsTypes, throwsTags, throwsInlineTags, cancel, stopByRemoteJdoc, ctx);
            if (jdText != null)
                return jdText;
            if ((inlineTags == null || !inlineTags.isEmpty()) &&

        if (superclass != null) { //NOI18N
            for (MethodDoc methodDoc : superclass.methods(false)) {
                if (mdoc.overrides(methodDoc)) {
                    Element e = ctx.second.elementFor(methodDoc);
                    boolean isLocalized = false;
                    if (e != null) {
                        inheritedPage = JavadocHelper.getJavadoc(e, cancel);

                            docURL = inheritedPage.getLocation();
                        }
                        if (!(isLocalized = isLocalized(docURL, e)))
                            ctx.first.getTree(e);
                    }
                    if (!isLocalized) {
                        List<Tag> inheritedInlineTags = null;

                            inheritedDocFor(mdoc, superclass, inheritedInlineTags,
                                    inheritedReturnTags, inheritedParamNames, inheritedParamTags,
                                    inheritedParamInlineTags, inheritedThrowsTypes,
                                    inheritedThrowsTags, inheritedThrowsInlineTags, cancel, stopByRemoteJdoc, ctx);
                        if (inheritedInlineTags != null && !inheritedInlineTags.isEmpty()) {
                            inlineTags.clear();
                            for (Tag tag : methodDoc.inlineTags()) {

                    returnTags != null && returnTags.isEmpty() ||
                    paramPos != null && !paramPos.isEmpty() ||
                    throwsTypes != null && !throwsTypes.isEmpty()) {
                if (stopByRemoteJdoc && isRemote(inheritedPage,docURL)) {
                    throw new RemoteJavadocException();
                }
                jdText = inheritedPage != null ? HTMLJavadocParser.getJavadocText(inheritedPage, false) : docURL != null ? HTMLJavadocParser.getJavadocText(docURL, false) : null;
                return jdText != null ? jdText : inheritedDocFor(mdoc, superclass, inlineTags,
                        returnTags, paramPos, paramTags,
                        paramInlineTags, throwsTypes,
                        throwsTags, throwsInlineTags, cancel, stopByRemoteJdoc, ctx);
            }
        }
        return null;

        return -1;

    }

    private static boolean isRemote(final JavadocHelper.TextStream page, final URL url) {
        return page != null ? page.getLocation().toString().startsWith("http") : url != null ? url.toString().startsWith("http") : false;
    }

    private static final class Now implements Future<String> {

        private final String value;

        Now(final String value) {
            this.value = value;
        }

        @Override
        public boolean cancel(boolean mayInterruptIfRunning) {
            return false;
        }

        @Override
        public boolean isCancelled() {
            return false;
        }

        @Override
        public boolean isDone() {
            return true;
        }

        @Override
        public String get() throws InterruptedException, ExecutionException {
            return value;
        }

        @Override
        public String get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
            return value;
        }
    }

    private static class RemoteJavadocException extends Exception {        
    }
}

Return to bug 194969