Example usage for org.eclipse.jdt.internal.codeassist CompletionEngine createNonGenericTypeSignature

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.codeassist CompletionEngine createNonGenericTypeSignature.

Prototype

public static char[] createNonGenericTypeSignature(char[] qualifiedPackageName, char[] qualifiedTypeName) 

Source Link

Usage

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

License:Apache License

private ICompletionProposal proposeNoImportType(char[] packageName, char[] simpleTypeName, int modifiers,
        int accessibility, char[] qualifiedTypeName, char[] fullyQualifiedName, boolean isQualified) {
    char[] completionName;
    if (isQualified) {
        completionName = fullyQualifiedName;
    } else {/*from www .  j  a va  2  s  .com*/
        completionName = simpleTypeName;
    }

    GroovyCompletionProposal proposal = createProposal(CompletionProposal.TYPE_REF,
            this.actualCompletionPosition - this.offset);
    proposal.setDeclarationSignature(packageName);
    proposal.setSignature(CompletionEngine.createNonGenericTypeSignature(packageName, simpleTypeName));
    proposal.setCompletion(completionName);
    proposal.setFlags(modifiers);
    proposal.setReplaceRange(this.offset, this.offset + this.replaceLength);
    proposal.setTokenRange(this.offset, this.actualCompletionPosition);
    proposal.setRelevance(RelevanceRules.ALL_RULES.getRelevance(fullyQualifiedName, allTypesInUnit,
            accessibility, modifiers));
    proposal.setTypeName(simpleTypeName);
    proposal.setAccessibility(accessibility);
    proposal.setPackageName(packageName);
    String completionString = new String(completionName);
    JavaTypeCompletionProposal javaCompletionProposal = new JavaTypeCompletionProposal(completionString, null,
            this.offset, this.replaceLength, ProposalUtils.getImage(proposal),
            ProposalUtils.createDisplayString(proposal), proposal.getRelevance(), completionString,
            javaContext);
    javaCompletionProposal.setRelevance(proposal.getRelevance());

    return javaCompletionProposal;
}

---

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

License:Apache License

private ICompletionProposal proposeImportableType(char[] packageName, char[] simpleTypeName, int modifiers,
        int accessibility, char[] qualifiedTypeName, char[] fullyQualifiedName, boolean isQualified) {
    char[] completionName;
    if (isQualified) {
        completionName = fullyQualifiedName;
    } else {/*  w  w w.  j  a  va2s .c  o m*/
        completionName = simpleTypeName;
    }

    GroovyCompletionProposal proposal = createProposal(CompletionProposal.TYPE_REF,
            this.actualCompletionPosition - this.offset);
    proposal.setDeclarationSignature(packageName);
    proposal.setSignature(CompletionEngine.createNonGenericTypeSignature(packageName, simpleTypeName));
    proposal.setCompletion(completionName);
    proposal.setFlags(modifiers);
    proposal.setReplaceRange(this.offset, this.offset + this.replaceLength);
    proposal.setTokenRange(this.offset, this.actualCompletionPosition);
    proposal.setRelevance(RelevanceRules.ALL_RULES.getRelevance(fullyQualifiedName, allTypesInUnit,
            accessibility, modifiers));
    proposal.setNameLookup(nameLookup);
    proposal.setTypeName(simpleTypeName);
    proposal.setAccessibility(accessibility);
    proposal.setPackageName(packageName);

    LazyGenericTypeProposal javaCompletionProposal = new LazyGenericTypeProposal(proposal, javaContext);
    javaCompletionProposal.setTriggerCharacters(ProposalUtils.TYPE_TRIGGERS);
    javaCompletionProposal.setRelevance(proposal.getRelevance());
    ImportRewrite r = groovyRewriter.getImportRewrite(monitor);
    if (r != null) {
        ReflectionUtils.setPrivateField(LazyJavaTypeCompletionProposal.class, "fImportRewrite",
                javaCompletionProposal, r);
    }
    return javaCompletionProposal;
}

---

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

License:Apache License

private ICompletionProposal proposeConstructor(char[] simpleTypeName, int parameterCount, char[] signature,
        char[][] parameterTypes, char[][] parameterNames, int modifiers, char[] packageName, int typeModifiers,
        int accessibility, char[] typeName, char[] fullyQualifiedName, boolean isQualified, int extraFlags) {

    // only show context information and only for methods
    // that exactly match the name. This happens when we are at the
    // start of an argument or an open paren
    String simpleTypeNameStr = String.valueOf(simpleTypeName);
    String fullyQualifiedNameStr = String.valueOf(fullyQualifiedName);
    if (contextOnly && !completionExpression.equals(simpleTypeNameStr)
            && !completionExpression.equals(fullyQualifiedNameStr)) {
        return null;
    }// www  . j av a2s . c  om

    char[] typeCompletion;
    if (isQualified) {
        typeCompletion = fullyQualifiedName;
        if (packageName == null || packageName.length == 0) {
            typeCompletion = simpleTypeName;
        }
    } else {
        typeCompletion = simpleTypeName;
    }

    float relevanceMultiplier = 1;
    relevanceMultiplier += accessibility == IAccessRule.K_ACCESSIBLE ? 2 : -1;
    relevanceMultiplier += computeRelevanceForCaseMatching(this.completionExpression.toCharArray(),
            simpleTypeName);

    int augmentedModifiers = modifiers;
    if (Flags.isDeprecated(typeModifiers)) {
        augmentedModifiers |= Flags.AccDeprecated;
    }

    if (parameterCount == -1) {
        // default constructor
        parameterNames = CharOperation.NO_CHAR_CHAR;
        parameterTypes = CharOperation.NO_CHAR_CHAR;
    } else {
        int parameterNamesLength = parameterNames == null ? 0 : parameterNames.length;
        if (parameterCount != parameterNamesLength) {
            parameterNames = null;
        }
    }

    GroovyCompletionProposal proposal = createProposal(
            contextOnly ? CompletionProposal.METHOD_REF : CompletionProposal.CONSTRUCTOR_INVOCATION,
            offset - 1);
    char[] declarationSignature = CompletionEngine.createNonGenericTypeSignature(packageName, typeName);
    proposal.setDeclarationSignature(declarationSignature);

    if (contextOnly) {
        proposal.setReplaceRange(actualCompletionPosition, actualCompletionPosition);
        proposal.setTokenRange(actualCompletionPosition, actualCompletionPosition);
        proposal.setCompletion(CharOperation.NO_CHAR);
    } else {
        // otherwise this is a normal constructor proposal
        proposal.setCompletion(this.completionExpression.toCharArray());
        // looks strange, but this is just copying similar code in
        // CompletionEngine.java
        proposal.setReplaceRange(this.offset + this.replaceLength, this.offset + this.replaceLength);
        proposal.setTokenRange(this.offset, this.actualCompletionPosition);
        proposal.setCompletion(new char[] { '(', ')' });

        // provides the import statement
        GroovyCompletionProposal typeProposal = createTypeProposal(packageName, typeModifiers, accessibility,
                typeName, fullyQualifiedName, isQualified, typeCompletion, augmentedModifiers,
                declarationSignature);
        proposal.setRequiredProposals(new CompletionProposal[] { typeProposal });
    }

    if (signature == null) {
        proposal.setSignature(createConstructorSignature(parameterTypes, isQualified));
    } else {
        char[] copy = new char[signature.length];
        System.arraycopy(signature, 0, copy, 0, copy.length);
        CharOperation.replace(copy, '/', '.');
        proposal.setSignature(copy);
    }

    if (parameterNames != null) {
        proposal.setParameterNames(parameterNames);
    } else {
        proposal.setHasNoParameterNamesFromIndex(true);
        if (mockEngine == null) {
            // used for caching types only
            mockEngine = new CompletionEngine(null, new CompletionRequestor() {

                @Override
                public void accept(CompletionProposal proposal) {

                }
            }, null, null, null, null);
        }
        proposal.setCompletionEngine(mockEngine);
    }

    proposal.setDeclarationPackageName(packageName);
    proposal.setDeclarationTypeName(simpleTypeName);
    proposal.setParameterTypeNames(parameterTypes);
    // proposal.setParameterPackageNames(); not right
    proposal.setName(simpleTypeName);

    proposal.setIsContructor(true);

    proposal.setRelevance(Relevance.MEDIUM_HIGH.getRelevance(relevanceMultiplier));

    proposal.setFlags(augmentedModifiers);

    proposal.setTypeName(simpleTypeName);
    proposal.setAccessibility(typeModifiers);
    proposal.setPackageName(packageName);

    LazyJavaCompletionProposal lazyProposal = new GroovyJavaMethodCompletionProposal(proposal, javaContext,
            getProposalOptions());
    lazyProposal.setRelevance(proposal.getRelevance());
    if (proposal.hasParameters()) {
        lazyProposal.setTriggerCharacters(ProposalUtils.METHOD_WITH_ARGUMENTS_TRIGGERS);
    } else {
        lazyProposal.setTriggerCharacters(ProposalUtils.METHOD_TRIGGERS);
    }
    ImportRewrite r = groovyRewriter.getImportRewrite(monitor);
    if (r != null) {
        ReflectionUtils.setPrivateField(LazyJavaTypeCompletionProposal.class, "fImportRewrite", lazyProposal,
                r);
    }
    if (contextOnly) {
        ((GroovyJavaMethodCompletionProposal) lazyProposal).contextOnly();
    }

    return lazyProposal;
}

---

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

License:Apache License

/**
 * @param packageName//from w w w .j  a  v  a2 s.  c om
 * @param typeModifiers
 * @param accessibility
 * @param typeName
 * @param fullyQualifiedName
 * @param isQualified
 * @param typeCompletion
 * @param augmentedModifiers
 * @param declarationSignature
 * @return
 */
private GroovyCompletionProposal createTypeProposal(char[] packageName, int typeModifiers, int accessibility,
        char[] typeName, char[] fullyQualifiedName, boolean isQualified, char[] typeCompletion,
        int augmentedModifiers, char[] declarationSignature) {
    GroovyCompletionProposal typeProposal = createProposal(CompletionProposal.TYPE_REF,
            this.actualCompletionPosition - 1);
    typeProposal.setNameLookup(nameLookup);
    typeProposal.setDeclarationSignature(declarationSignature);
    typeProposal.setSignature(CompletionEngine.createNonGenericTypeSignature(packageName, typeName));
    typeProposal.setPackageName(packageName);
    typeProposal.setTypeName(typeName);
    typeProposal.setFlags(typeModifiers);

    typeProposal.setCompletion(typeCompletion);
    typeProposal.setReplaceRange(this.offset, this.offset + this.replaceLength);
    typeProposal.setTokenRange(this.offset, this.offset + this.replaceLength);
    typeProposal.setRelevance(RelevanceRules.ALL_RULES.getRelevance(fullyQualifiedName, allTypesInUnit,
            accessibility, augmentedModifiers));
    return typeProposal;
}

---