Example usage for org.eclipse.jdt.core Signature createMethodSignature

List of usage examples for org.eclipse.jdt.core Signature createMethodSignature

Introduction

In this page you can find the example usage for org.eclipse.jdt.core Signature createMethodSignature.

Prototype

public static String createMethodSignature(String[] parameterTypes, String returnType) 

Source Link

Document

Creates a method signature from the given parameter and return type signatures.

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.SourceMethod.java

License:Open Source License

/**
 * @see org.eclipse.jdt.core.IMethod/*  www.j  a v  a  2 s.  co m*/
 */
public String getSignature() throws JavaModelException {
    SourceMethodElementInfo info = (SourceMethodElementInfo) getElementInfo();
    return Signature.createMethodSignature(this.parameterTypes,
            Signature.createTypeSignature(info.getReturnTypeName(), false));
}

From source file:com.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * @param owner/*from   w w w  .ja va 2s.  c  om*/
 * @param unresolvedSignature
 * @return the resolved method signature for unresolvedSignature in owner
 */
public static String resolveMethodSignature(final IType owner, final String unresolvedSignature) {
    // get the list of parameters
    final String[] parameters = Signature.getParameterTypes(unresolvedSignature);

    for (int i = 0; i < parameters.length; i++) {
        // try to full resolve the type
        parameters[i] = resolveTypeSignature(owner, parameters[i]);
    }

    // resolve return type
    final String resolvedReturn = resolveTypeSignature(owner, Signature.getReturnType(unresolvedSignature));

    return Signature.createMethodSignature(parameters, resolvedReturn);
}

From source file:de.ovgu.featureide.core.CorePlugin.java

License:Open Source License

public List<CompletionProposal> extendedModules_getCompl(IFeatureProject featureProject, String featureName) {
    final LinkedList<CompletionProposal> ret_List = new LinkedList<CompletionProposal>();
    final ProjectSignatures signatures = featureProject.getProjectSignatures();

    if (signatures != null) {
        SignatureIterator it = signatures.iterator();
        it.addFilter(new ContextFilter(featureName, signatures));

        while (it.hasNext()) {
            AbstractSignature curMember = it.next();
            CompletionProposal pr = null;

            if (curMember instanceof AbstractMethodSignature) {
                pr = CompletionProposal.create(CompletionProposal.METHOD_REF, 0);
                final AbstractMethodSignature methSig = (AbstractMethodSignature) curMember;
                final List<String> sig = methSig.getParameterTypes();

                //TODO differentiate between possible types
                char[][] c = new char[][] { {} };
                if (sig.size() > 0) {
                    c = new char[sig.size()][];
                    int i = 0;
                    for (String parameterType : sig) {
                        String parameterTypeToChar = "L" + parameterType + ";";
                        c[i++] = parameterTypeToChar.toCharArray();
                    }/*from  www  .  ja v a2s. co  m*/
                }

                String returnType = "L" + methSig.getReturnType() + ";";
                pr.setSignature(Signature.createMethodSignature(c, returnType.toCharArray()));
                String declType = "L" + methSig.getFullName().replaceAll("." + methSig.getName(), "") + ";";
                pr.setDeclarationSignature(declType.toCharArray());
            } else if (curMember instanceof AbstractFieldSignature) {
                pr = CompletionProposal.create(CompletionProposal.FIELD_REF, 0);
            } else if (curMember instanceof AbstractClassSignature) {
                pr = CompletionProposal.create(CompletionProposal.TYPE_REF, 0);
                pr.setSignature(Signature.createTypeSignature(curMember.getFullName(), true).toCharArray());
            }

            if (pr != null) {
                pr.setFlags(getFlagOfSignature(curMember));
                pr.setName(curMember.getName().toCharArray());
                pr.setCompletion(curMember.getName().toCharArray());

                ret_List.add(pr);
            }
        }
    }
    return ret_List;
}

From source file:de.ovgu.featureide.core.mpl.MPLPlugin.java

License:Open Source License

public List<CompletionProposal> extendedModules_getCompl(IFeatureProject project, String featureName) {
    final LinkedList<CompletionProposal> ret_List = new LinkedList<CompletionProposal>();

    InterfaceProject interfaceProject = getInterfaceProject(project.getProject());
    if (interfaceProject != null) {
        final ProjectSignatures signatures = interfaceProject.getProjectSignatures();
        if (signatures != null) {
            SignatureIterator it = signatures.createIterator();
            it.addFilter(new ContextFilter(featureName, interfaceProject));
            //            Iterator<AbstractSignature> it = signatures.getIterator(new ContextFilter(featureName, interfaceProject));

            while (it.hasNext()) {
                AbstractSignature curMember = it.next();
                CompletionProposal pr = null;

                if (curMember instanceof AbstractMethodSignature) {
                    pr = CompletionProposal.create(CompletionProposal.METHOD_REF, 0);
                    pr.setSignature(Signature.createMethodSignature(new char[][] { {} }, new char[] {}));
                } else if (curMember instanceof AbstractFieldSignature) {
                    pr = CompletionProposal.create(CompletionProposal.FIELD_REF, 0);
                    //                  pr.setDeclarationSignature(Signature.createTypeSignature(cur.getSignature().getFullName(), true).toCharArray());
                } else if (curMember instanceof AbstractClassSignature) {
                    pr = CompletionProposal.create(CompletionProposal.TYPE_REF, 0);
                    pr.setSignature(Signature.createTypeSignature(curMember.getFullName(), true).toCharArray());
                }//w w  w.  j  a va 2  s .c  o  m

                if (pr != null) {
                    //                  pr2.setDeclarationSignature(Signature.createTypeSignature(cur.getSignature().getFullName(), true).toCharArray());
                    pr.setFlags(Flags.AccPublic);
                    pr.setName(curMember.getName().toCharArray());
                    pr.setCompletion(curMember.getName().toCharArray());

                    ret_List.add(pr);
                }
            }
        } else {
            interfaceProject.loadSignatures(false);
        }
    }
    return ret_List;
}

From source file:org.bonitasoft.studio.groovy.ui.contentassist.VariablesTypeCompletionProposal.java

License:Open Source License

@Override
public List<ICompletionProposal> computeCompletionProposals(final ContentAssistInvocationContext context,
        final IProgressMonitor monitor) {
    final List<ICompletionProposal> list = new ArrayList<ICompletionProposal>();
    if (context instanceof JavaContentAssistInvocationContext) {
        final ICompilationUnit unit = ((JavaContentAssistInvocationContext) context).getCompilationUnit();
        if (unit instanceof GroovyCompilationUnit) {
            final ITextViewer viewer = context.getViewer();
            final List<ScriptVariable> nodes = (List<ScriptVariable>) viewer.getTextWidget()
                    .getData(GroovyViewer.PROCESS_VARIABLES_DATA_KEY);
            final List<String> keyWords = (List<String>) viewer.getTextWidget()
                    .getData(GroovyViewer.BONITA_KEYWORDS_DATA_KEY);
            if (((GroovyCompilationUnit) unit).getModuleNode() == null) {
                return Collections.emptyList();
            }/* ww  w  .jav a2 s .  c  o  m*/
            final ContentAssistContext assistContext = new GroovyCompletionProposalComputer()
                    .createContentAssistContext((GroovyCompilationUnit) unit, context.getInvocationOffset(),
                            context.getDocument());
            CharSequence prefix = null;
            try {
                prefix = context.computeIdentifierPrefix();
            } catch (final BadLocationException e) {
                BonitaStudioLog.error(e);
            }

            if (assistContext != null && assistContext.completionNode instanceof VariableExpression) {
                try {
                    final VariableExpression expr = (VariableExpression) assistContext.completionNode;
                    if (nodes != null) {
                        for (final ScriptVariable f : nodes) {
                            if (expr.getName().equals(f.getName())) {
                                final IType type = javaProject.findType(f.getType());
                                for (final IMethod m : type.getMethods()) {
                                    if (m.getElementName().startsWith(prefix.toString())) {
                                        final CompletionProposal proposal = CompletionProposal.create(
                                                CompletionProposal.METHOD_REF, context.getInvocationOffset());
                                        proposal.setName(m.getElementName().toCharArray());
                                        proposal.setCompletion(
                                                m.getElementName().substring(prefix.length()).toCharArray());
                                        proposal.setFlags(m.getFlags());

                                        if (prefix.length() == m.getElementName().length()) {
                                            proposal.setReplaceRange(context.getInvocationOffset(),
                                                    context.getInvocationOffset());
                                            proposal.setReceiverRange(0, 0);
                                        } else {
                                            proposal.setReplaceRange(
                                                    context.getInvocationOffset() - prefix.length(),
                                                    context.getInvocationOffset());
                                            proposal.setReceiverRange(prefix.length(), prefix.length());
                                        }

                                        final char[][] parameters = new char[m.getParameterNames().length][256];
                                        for (int i = 0; i < m.getParameterNames().length; i++) {
                                            parameters[i] = m.getParameterNames()[i].toCharArray();
                                        }

                                        proposal.setParameterNames(parameters);
                                        proposal.setDeclarationSignature(
                                                Signature
                                                        .createTypeSignature(
                                                                m.getDeclaringType().getElementName(), true)
                                                        .toCharArray());
                                        proposal.setSignature(Signature
                                                .createMethodSignature(m.getParameterTypes(), m.getReturnType())
                                                .toCharArray());
                                        list.add(new JavaMethodCompletionProposal(proposal,
                                                (JavaContentAssistInvocationContext) context));
                                    }
                                }
                            }
                        }
                    }
                    if (keyWords != null) {
                        for (final String keyWord : keyWords) {
                            if (expr.getName().equals(keyWord)) {
                                final IType type = javaProject.findType(
                                        BonitaSyntaxHighlighting.getTypeForKeyWord(keyWord).getName());
                                for (final IMethod m : type.getMethods()) {
                                    if (m.getElementName().startsWith(prefix.toString())) {
                                        final CompletionProposal proposal = CompletionProposal.create(
                                                CompletionProposal.METHOD_REF, context.getInvocationOffset());
                                        proposal.setName(m.getElementName().toCharArray());
                                        proposal.setCompletion(
                                                m.getElementName().substring(prefix.length()).toCharArray());
                                        proposal.setFlags(m.getFlags());
                                        proposal.getCompletion();

                                        if (prefix.length() == m.getElementName().length()) {
                                            proposal.setReplaceRange(context.getInvocationOffset(),
                                                    context.getInvocationOffset());
                                            proposal.setReceiverRange(0, 0);
                                        } else {
                                            proposal.setReplaceRange(
                                                    context.getInvocationOffset() - prefix.length(),
                                                    context.getInvocationOffset());
                                            proposal.setReceiverRange(prefix.length(), prefix.length());
                                        }

                                        final char[][] parameters = new char[m.getParameterNames().length][256];
                                        for (int i = 0; i < m.getParameterNames().length; i++) {
                                            parameters[i] = m.getParameterNames()[i].toCharArray();
                                        }

                                        proposal.setParameterNames(parameters);
                                        proposal.setDeclarationSignature(
                                                Signature
                                                        .createTypeSignature(
                                                                m.getDeclaringType().getElementName(), true)
                                                        .toCharArray());
                                        proposal.setSignature(Signature
                                                .createMethodSignature(m.getParameterTypes(), m.getReturnType())
                                                .toCharArray());
                                        list.add(new JavaMethodCompletionProposal(proposal,
                                                (JavaContentAssistInvocationContext) context));
                                    }
                                }
                            }
                        }
                    }
                } catch (final JavaModelException e) {
                    BonitaStudioLog.error(e);
                }

            }
        }

        return list;
    }

    return Collections.emptyList();
}

From source file:org.codehaus.groovy.eclipse.codeassist.processors.GroovyProposalTypeSearchRequestor.java

License:Apache License

/**
 * @param parameterTypes//from www .  j av a  2s .co m
 * @return
 */
private char[] createConstructorSignature(char[][] parameterTypes, boolean isQualified) {
    char[][] parameterTypeSigs;
    if (parameterTypes == null) {
        parameterTypeSigs = CharOperation.NO_CHAR_CHAR;
    } else {
        parameterTypeSigs = new char[parameterTypes.length][];
        for (int i = 0; i < parameterTypes.length; i++) {
            char[] copy = new char[parameterTypes[i].length];
            System.arraycopy(parameterTypes[i], 0, copy, 0, copy.length);
            CharOperation.replace(copy, '/', '.');
            parameterTypeSigs[i] = Signature.createCharArrayTypeSignature(copy, isQualified);
        }
    }
    return Signature.createMethodSignature(parameterTypeSigs, new char[] { 'V' });
}

From source file:org.codehaus.groovy.eclipse.codeassist.ProposalUtils.java

License:Apache License

/**
 * Includes named params. but not optional params
 *
 * @param node/*from w  w  w  .ja v  a  2  s.  co m*/
 * @param ignoreParameters number of parameters to ignore at the start
 * @return
 */
public static String createMethodSignatureStr(MethodNode node, int ignoreParameters) {
    String returnType = createTypeSignatureStr(node.getReturnType());
    Parameter[] parameters;
    if (node instanceof NamedArgsMethodNode) {
        parameters = ((NamedArgsMethodNode) node).getVisibleParams();
    } else {
        parameters = node.getParameters();
    }
    String[] parameterTypes = new String[parameters.length - ignoreParameters];
    for (int i = 0; i < parameterTypes.length; i++) {
        parameterTypes[i] = createTypeSignatureStr(parameters[i + ignoreParameters].getType());
    }
    return Signature.createMethodSignature(parameterTypes, returnType);
}

From source file:org.codehaus.groovy.eclipse.debug.ui.BreakpointLocationVerifierJob.java

License:Apache License

private String createMethodSignature(MethodNode node) {
    String returnType = createTypeSignatureStr(node.getReturnType());
    String[] parameterTypes = new String[node.getParameters().length];
    for (int i = 0; i < parameterTypes.length; i++) {
        parameterTypes[i] = createTypeSignatureStr(node.getParameters()[i].getType());
    }/*w  w w .j ava  2s .  co m*/
    return Signature.createMethodSignature(parameterTypes, returnType).replace('.', '/');
}

From source file:org.eclipse.ajdt.core.javaelements.AspectJMemberElement.java

License:Open Source License

/**
 * @see IMethod//from   w w w .j av a2s. c o  m
 */
public String getSignature() throws JavaModelException {
    AspectJMemberElementInfo info = (AspectJMemberElementInfo) getElementInfo();
    //return info.getSignature();
    char[] returnTypeName = info.getReturnTypeName();
    if (returnTypeName == null) {
        returnTypeName = "void".toCharArray();
    }
    return Signature.createMethodSignature(fParameterTypes,
            Signature.createTypeSignature(returnTypeName, false));
}

From source file:org.eclipse.jst.j2ee.internal.common.operations.SourceMethod.java

License:Open Source License

/**
 * @see Method#getSignature()//from   w w w . j  a v  a  2  s .co m
 */
public String getSignature() {
    List<SingleVariableDeclaration> parameters = method.parameters();
    List<String> parameterTypesList = new ArrayList<String>();
    for (SingleVariableDeclaration parameter : parameters) {
        parameterTypesList.add(parameter.getType().resolveBinding().getQualifiedName());
    }

    String[] parameterTypes = parameterTypesList.toArray(new String[] {});
    String returnType = method.getReturnType2().resolveBinding().getQualifiedName();

    return Signature.createMethodSignature(parameterTypes, returnType);
}