Example usage for org.eclipse.jdt.core CompletionProposal getDeclarationSignature

List of usage examples for org.eclipse.jdt.core CompletionProposal getDeclarationSignature

Introduction

In this page you can find the example usage for org.eclipse.jdt.core CompletionProposal getDeclarationSignature.

Prototype

public char[] getDeclarationSignature() 

Source Link

Document

Returns the type signature or package name or module name (9) of the relevant declaration in the context, or null if none.

Usage

From source file:at.bestsolution.fxide.jdt.editor.internal.MethodUtil.java

License:Open Source License

public MethodUtil(CompletionProposal proposal, IType type) {
    this.type = type;
    this.name = proposal.getName();
    this.methodSignature = proposal.getSignature();
    this.constructor = proposal.isConstructor();
    this.declSignature = proposal.getDeclarationSignature();
}

From source file:at.bestsolution.fxide.jdt.editor.JDTJavaDocSupport.java

License:Open Source License

private static IType getOwnerType(CompletionProposal proposal, IJavaProject jProject)
        throws JavaModelException {
    char[] declSignature = proposal.getDeclarationSignature();
    String typeName = SignatureUtil.stripSignatureToFQN(String.valueOf(declSignature));
    return jProject.findType(String.valueOf(typeName));
}

From source file:at.bestsolution.javafx.ide.jdt.internal.JavaEditor.java

License:Open Source License

@Inject
public JavaEditor(BorderPane pane, IEditorInput input) {
    editor = new SourceEditor();
    pane.setCenter(editor);// ww w  .  j  av  a  2  s .  co  m

    IResourceFileInput fsInput = (IResourceFileInput) input;
    try {
        unit = ((ICompilationUnit) JavaCore.create(fsInput.getFile()))
                .getWorkingCopy(new FXWorkingCopyOwner(new IProblemRequestor() {
                    private List<ProblemMarker> l = new ArrayList<>();

                    @Override
                    public boolean isActive() {
                        // TODO Auto-generated method stub
                        return true;
                    }

                    @Override
                    public void endReporting() {
                        setMarkers(l);
                    }

                    @Override
                    public void beginReporting() {
                        l.clear();
                    }

                    @Override
                    public void acceptProblem(IProblem problem) {
                        int linenumber = problem.getSourceLineNumber();
                        int startCol = problem.getSourceStart();
                        int endCol = problem.getSourceEnd();

                        if (endCol == startCol) {
                            endCol++;
                        }

                        String description = problem.getMessage();
                        ProblemMarker marker = new ProblemMarker(
                                problem.isError() ? at.bestsolution.javafx.ide.editor.ProblemMarker.Type.ERROR
                                        : at.bestsolution.javafx.ide.editor.ProblemMarker.Type.WARNING,
                                linenumber, startCol, endCol, description);
                        l.add(marker);
                    }
                }), new NullProgressMonitor());
    } catch (JavaModelException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    final Document doc = createDocument(unit);
    editor.setDocument(doc);
    editor.setContentProposalComputer(new ContentProposalComputer() {

        @Override
        public List<Proposal> computeProposals(String line, String prefix, int offset) {
            final List<Proposal> l = new ArrayList<ContentProposalComputer.Proposal>();

            try {
                unit.codeComplete(offset, new CompletionRequestor() {

                    @Override
                    public void accept(CompletionProposal proposal) {
                        String completion = new String(proposal.getCompletion());

                        if (!Flags.isPublic(proposal.getFlags())) {
                            return;
                        }

                        if (proposal.getKind() == CompletionProposal.METHOD_REF) {
                            String sig = Signature.toString(new String(proposal.getSignature()),
                                    new String(proposal.getName()), null, false, false);
                            StyledString s = new StyledString(sig + " : " + Signature.getSimpleName(Signature
                                    .toString(Signature.getReturnType(new String(proposal.getSignature())))));
                            s.appendString(
                                    " - " + Signature.getSignatureSimpleName(
                                            new String(proposal.getDeclarationSignature())),
                                    Style.colored("#AAAAAA"));

                            l.add(new Proposal(Type.METHOD, completion, s));
                        } else if (proposal.getKind() == CompletionProposal.FIELD_REF) {
                            StyledString s = new StyledString(
                                    completion + " : "
                                            + (proposal.getSignature() != null
                                                    ? Signature.getSignatureSimpleName(
                                                            new String(proposal.getSignature()))
                                                    : "<unknown>"));
                            s.appendString(
                                    " - " + (proposal.getDeclarationSignature() != null
                                            ? Signature.getSignatureSimpleName(
                                                    new String(proposal.getDeclarationSignature()))
                                            : "<unknown>"),
                                    Style.colored("#AAAAAA"));
                            l.add(new Proposal(Type.FIELD, completion, s));
                        } else if (proposal.getKind() == CompletionProposal.TYPE_REF) {
                            if (proposal.getAccessibility() == IAccessRule.K_NON_ACCESSIBLE) {
                                return;
                            }

                            StyledString s = new StyledString(
                                    Signature.getSignatureSimpleName(new String(proposal.getSignature())));
                            s.appendString(" - " + new String(proposal.getDeclarationSignature()),
                                    Style.colored("#AAAAAA"));
                            l.add(new Proposal(Type.TYPE, new String(proposal.getCompletion()), s));
                        } else {
                            System.err.println(proposal);
                        }
                    }
                });
            } catch (JavaModelException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return l;
        }

    });
    editor.setSaveCallback(new Runnable() {

        @Override
        public void run() {
            try {
                unit.commitWorkingCopy(true, null);
            } catch (JavaModelException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });

    try {
        unit.reconcile(ICompilationUnit.NO_AST, true, null, null);
    } catch (JavaModelException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

From source file:com.amashchenko.eclipse.strutsclipse.java.SimpleJavaProposalCollector.java

License:Apache License

@Override
protected IJavaCompletionProposal createJavaCompletionProposal(CompletionProposal proposal) {
    if (collectMethods) {
        if (CompletionProposal.METHOD_REF == proposal.getKind() && Flags.isPublic(proposal.getFlags())) {
            char[] sig = proposal.getSignature();
            char[] declSig = proposal.getDeclarationSignature();
            // collect methods suitable for action methods ignoring Object
            // methods
            if (sig != null && declSig != null && ACTION_METHOD_SIGNATURE.equals(String.valueOf(sig))
                    && !OBJECT_SIGNATURE.equals(String.valueOf(declSig))) {
                return new SimpleJavaCompletionProposal(proposal, getInvocationContext(),
                        getImage(getLabelProvider().createImageDescriptor(proposal)));
            }/*from  w  w  w. j  av a 2 s .  co  m*/
        }
    } else {
        // collect packages and classes suitable for actions
        if ((CompletionProposal.PACKAGE_REF == proposal.getKind()
                || CompletionProposal.TYPE_REF == proposal.getKind()) && !Flags.isAbstract(proposal.getFlags())
                && !Flags.isInterface(proposal.getFlags()) && !Flags.isEnum(proposal.getFlags())) {
            return new SimpleJavaCompletionProposal(proposal, getInvocationContext(),
                    getImage(getLabelProvider().createImageDescriptor(proposal)));
        }
    }
    return null;
}

From source file:com.google.gwt.eclipse.core.uibinder.contentassist.computers.ProposalGeneratingCompletionRequestor.java

License:Open Source License

protected ICompletionProposal createProposal(CompletionProposal javaProposal) {
    String completion = String.valueOf(javaProposal.getCompletion());
    int kind = javaProposal.getKind();
    if (kind == CompletionProposal.TYPE_REF) {
        // Make sure it is fully qualified
        completion = JavaContentAssistUtilities.getFullyQualifiedTypeName(javaProposal);
    }/*  www . j a  v  a  2  s.com*/

    if (forceFullyQualifiedFieldNames
            && (kind == CompletionProposal.FIELD_IMPORT || kind == CompletionProposal.FIELD_REF)) {
        char[] decSig = javaProposal.getDeclarationSignature();
        if (decSig != null && decSig.length > 2) {
            // declaration signatures for objects are like Ljava.lang.String;, so lop off first
            // and last chars
            completion = new String(decSig, 1, decSig.length - 2) + "."
                    + new String(javaProposal.getCompletion());
            completion = completion.replace('$', '.');
        }
    }

    ICompletionProposal jdtCompletionProposal = JavaContentAssistUtilities
            .getJavaCompletionProposal(javaProposal, context, javaProject);
    return ReplacementCompletionProposal.fromExistingCompletionProposal(completion, replaceOffset,
            replaceLength, jdtCompletionProposal);
}

From source file:edu.brown.cs.bubbles.bedrock.BedrockUtil.java

License:Open Source License

/********************************************************************************/

static void outputCompletion(CompletionProposal cp, IvyXmlWriter xw) {
    xw.begin("COMPLETION");
    fieldValue(xw, "ACCESSIBILITY", cp.getAccessibility(), accessibility_types);
    if (cp.isConstructor())
        xw.field("CONSTRUCTOR", true);
    xw.field("TEXT", cp.getCompletion());
    xw.field("INDEX", cp.getCompletionLocation());
    xw.field("DECLKEY", cp.getDeclarationKey());
    switch (cp.getKind()) {
    case CompletionProposal.ANNOTATION_ATTRIBUTE_REF:
    case CompletionProposal.ANONYMOUS_CLASS_DECLARATION:
    case CompletionProposal.FIELD_IMPORT:
    case CompletionProposal.FIELD_REF:
    case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER:
    case CompletionProposal.METHOD_IMPORT:
    case CompletionProposal.METHOD_REF:
    case CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER:
    case CompletionProposal.METHOD_DECLARATION:
    case CompletionProposal.POTENTIAL_METHOD_DECLARATION:
        xw.field("DECLSIGN", cp.getDeclarationSignature());
        break;//from   www. ja v a2s.  co  m
    case CompletionProposal.PACKAGE_REF:
    case CompletionProposal.TYPE_IMPORT:
    case CompletionProposal.TYPE_REF:
        xw.field("DOTNAME", cp.getDeclarationSignature());
        break;
    }
    fieldFlags(xw, "ACCESS", cp.getFlags(), access_flags);
    xw.field("FLAGS", cp.getFlags());
    xw.field("KEY", cp.getKey());
    xw.field("NAME", cp.getName());
    xw.field("RELEVANCE", cp.getRelevance());
    xw.field("REPLACE_START", cp.getReplaceStart());
    xw.field("REPLACE_END", cp.getReplaceEnd());
    xw.field("SIGNATURE", cp.getSignature());
    xw.field("TOKEN_START", cp.getTokenStart());
    xw.field("TOKEN_END", cp.getTokenEnd());
    fieldValue(xw, "KIND", cp.getKind(), completion_types);
    if (cp instanceof ICompletionProposalExtension4) {
        ICompletionProposalExtension4 icp4 = (ICompletionProposalExtension4) cp;
        xw.field("AUTO", icp4.isAutoInsertable());
    }

    if (CompletionFlags.isStaticImport(cp.getAdditionalFlags()))
        xw.field("STATICIMPORT", true);

    if (cp.getKind() == CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER
            || cp.getKind() == CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER) {
        xw.field("RECEIVER_SIGN", cp.getReceiverSignature());
        xw.field("RECEIVER_START", cp.getReceiverStart());
        xw.field("RECEIVER_END", cp.getReceiverEnd());
    }
    xw.field("RCVR", cp.getReceiverSignature());

    xw.cdataElement("DESCRIPTION", cp.toString());

    CompletionProposal[] rq = cp.getRequiredProposals();
    if (rq != null) {
        xw.begin("REQUIRED");
        for (CompletionProposal xcp : rq)
            outputCompletion(xcp, xw);
        xw.end("REQUIRED");
    }

    xw.end("COMPLETION");
}

From source file:org.eclipse.ajdt.internal.core.contentassist.ProposalRequestorWrapper.java

License:Open Source License

protected boolean shouldAccept(CompletionProposal proposal) {
    if (proposal.getKind() == CompletionProposal.FIELD_REF
            || proposal.getKind() == CompletionProposal.METHOD_REF) {

        if (world == null) {
            world = new AJWorldFacade(unit.getJavaProject().getProject());
        }// ww w.ja  v a2  s.c o m

        ITDInfo info = world.findITDInfoFromTargetType(proposal.getDeclarationSignature(), proposal.getName());
        if (info != null) {
            if (info.accessibility == Accessibility.PUBLIC) {
                // accessible everywhere
                return true;
            } else if (info.accessibility == Accessibility.PACKAGE) {
                // accessible only in package of declaring aspect
                if (((IPackageFragment) unit.getParent()).getElementName().equals(info.packageDeclaredIn)) {
                    int oldFlags = proposal.getFlags();
                    oldFlags |= Flags.AccDefault;
                    oldFlags &= ~Flags.AccPublic;
                    proposal.setFlags(oldFlags);
                    return true;
                }
            } else if (info.accessibility == Accessibility.PRIVATE) {
                // accessible only in declaring aspect's compilation unit
                if (unit.getElementName().startsWith(info.topLevelAspectName + ".")
                        && ((IPackageFragment) unit.getParent()).getElementName()
                                .equals(info.packageDeclaredIn)) {

                    int oldFlags = proposal.getFlags();
                    oldFlags |= Flags.AccPrivate;
                    oldFlags &= ~Flags.AccPublic;
                    proposal.setFlags(oldFlags);
                    return true;
                }

            }
            return false;
        } else {
            // not an ITD
            return true;
        }
    } else if (proposal.getKind() == CompletionProposal.LOCAL_VARIABLE_REF) {
        // check to see if this is the proposal that has been added by the context switch for ITDs
        if (contextSwitchIgnore(proposal)) {
            return false;
        }
    } else if (proposal.getKind() == CompletionProposal.TYPE_REF) {
        // check to see if this is an ITIT type that should not be see
        char[] typeName = (char[]) ReflectionUtils.getPrivateField(InternalCompletionProposal.class, "typeName",
                (InternalCompletionProposal) proposal);
        if (typeName != null && CharOperation.contains('$', typeName)) {
            return false;
        }
    }
    return true;
}

From source file:org.eclipse.flux.jdt.services.CompletionProposalDescriptionProvider.java

License:Open Source License

/**
 * Extracts the fully qualified name of the declaring type of a method
 * reference./*from   w  w  w  . j  av  a  2 s  . c o m*/
 *
 * @param methodProposal a proposed method
 * @return the qualified name of the declaring type
 */
private String extractDeclaringTypeFQN(CompletionProposal methodProposal) {
    char[] declaringTypeSignature = methodProposal.getDeclarationSignature();
    // special methods may not have a declaring type: methods defined on arrays etc.
    // TODO remove when bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=84690 gets fixed
    if (declaringTypeSignature == null)
        return "java.lang.Object"; //$NON-NLS-1$
    return SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
}

From source file:org.eclipse.flux.jdt.services.CompletionProposalDescriptionProvider.java

License:Open Source License

StringBuilder createLabelWithTypeAndDeclaration(CompletionProposal proposal) {
    char[] name = proposal.getCompletion();
    if (!isThisPrefix(name))
        name = proposal.getName();/* w  w  w  . java 2s.c  o m*/
    StringBuilder buf = new StringBuilder();
    buf.append("[");

    buf.append("{\"value\":\"");

    buf.append(name);
    char[] typeName = Signature.getSignatureSimpleName(proposal.getSignature());
    if (typeName.length > 0) {
        buf.append(VAR_TYPE_SEPARATOR);
        buf.append(typeName);
    }
    buf.append("\"}");

    char[] declaration = proposal.getDeclarationSignature();
    if (declaration != null) {
        declaration = Signature.getSignatureSimpleName(declaration);
        if (declaration.length > 0) {
            buf.append(",");
            buf.append("{\"value\":\"");
            buf.append(QUALIFIER_SEPARATOR);
            if (proposal.getRequiredProposals() != null) {
                String declaringType = extractDeclaringTypeFQN(proposal);
                String qualifier = Signature.getQualifier(declaringType);
                if (qualifier.length() > 0) {
                    buf.append(qualifier);
                    buf.append('.');
                }
            }
            buf.append(declaration);
            buf.append("\",\"style\":{");
            buf.append("\"color\":\"#AAAAAA\"");
            buf.append("}");
            buf.append("}");
        }
    }
    buf.append("]");
    return buf;
}

From source file:org.eclipse.flux.jdt.services.CompletionProposalDescriptionProvider.java

License:Open Source License

StringBuilder createPackageProposalLabel(CompletionProposal proposal) {
    Assert.isTrue(proposal.getKind() == CompletionProposal.PACKAGE_REF);
    StringBuilder buf = new StringBuilder();
    buf.append("[");
    buf.append("{\"value\":\"");
    buf.append(String.valueOf(proposal.getDeclarationSignature()));
    buf.append("\"}");
    buf.append("]");
    return buf;//  w ww  .j  a v a2  s  .co m
}