/**
* Returns <code>true</code> if <code>proposal</code> is filtered, e.g. should not be proposed to
* the user, <code>false</code> if it is valid.
*
* <p>Subclasses may extends this method. The default implementation filters proposals set to be
* ignored via {@linkplain CompletionRequestor#setIgnored(int, boolean) setIgnored} and types set
* to be ignored in the preferences.
*
* @param proposal the proposal to filter
* @return <code>true</code> to filter <code>proposal</code>, <code>false</code> to let it pass
*/
protected boolean isFiltered(CompletionProposal proposal) {
if (isIgnored(proposal.getKind())) {
return true;
}
char[] declaringType = getDeclaringType(proposal);
return declaringType != null && TypeFilter.isFiltered(declaringType);
}
/**
* Computes the relevance for a given <code>CompletionProposal</code>.
*
* <p>Subclasses may replace, but usually should not need to.
*
* @param proposal the proposal to compute the relevance for
* @return the relevance for <code>proposal</code>
*/
protected int computeRelevance(CompletionProposal proposal) {
final int baseRelevance = proposal.getRelevance() * 16;
switch (proposal.getKind()) {
case CompletionProposal.LIBRARY_PREFIX:
return baseRelevance + 0;
case CompletionProposal.LABEL_REF:
return baseRelevance + 1;
case CompletionProposal.KEYWORD:
return baseRelevance + 2;
case CompletionProposal.TYPE_REF:
// case CompletionProposal.ANONYMOUS_CLASS_DECLARATION:
// case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION:
return baseRelevance + 3;
case CompletionProposal.METHOD_REF:
case CompletionProposal.CONSTRUCTOR_INVOCATION:
case CompletionProposal.METHOD_NAME_REFERENCE:
case CompletionProposal.METHOD_DECLARATION:
// case CompletionProposal.ANNOTATION_ATTRIBUTE_REF:
return baseRelevance + 4;
case CompletionProposal.POTENTIAL_METHOD_DECLARATION:
return baseRelevance + 4 /* + 99 */;
case CompletionProposal.FIELD_REF:
return baseRelevance + 5;
case CompletionProposal.LOCAL_VARIABLE_REF:
case CompletionProposal.VARIABLE_DECLARATION:
return baseRelevance + 6;
case CompletionProposal.ARGUMENT_LIST:
return baseRelevance + 7;
default:
return baseRelevance;
}
}
/**
* Tells whether required proposals are supported by this proposal.
*
* @return <code>true</code> if required proposals are supported by this proposal
*/
protected boolean isSupportingRequiredProposals() {
if (fInvocationContext == null) {
return false;
}
ProposalInfo proposalInfo = getProposalInfo();
if (!(proposalInfo instanceof MemberProposalInfo)) {
return false;
}
CompletionProposal proposal = ((MemberProposalInfo) proposalInfo).fProposal;
return proposal != null
&& (proposal.getKind() == CompletionProposal.METHOD_REF
|| proposal.getKind() == CompletionProposal.FIELD_REF
|| proposal.getKind() == CompletionProposal.TYPE_REF
// || proposal.getKind() ==
// CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION
|| proposal.getKind() == CompletionProposal.CONSTRUCTOR_INVOCATION);
}
/**
* Creates a new Dart completion proposal from a core proposal. This may involve computing the
* display label and setting up some context.
*
* <p>This method is called for every proposal that will be displayed to the user, which may be
* hundreds. Implementations should therefore defer as much work as possible: Labels should be
* computed lazily to leverage virtual table usage, and any information only needed when
* <em>applying</em> a proposal should not be computed yet.
*
* <p>Implementations may return <code>null</code> if a proposal should not be included in the
* list presented to the user.
*
* <p>Subclasses may extend or replace this method.
*
* @param proposal the core completion proposal to create a UI proposal for
* @return the created Dart completion proposal, or <code>null</code> if no proposal should be
* displayed
*/
protected IDartCompletionProposal createDartCompletionProposal(CompletionProposal proposal) {
switch (proposal.getKind()) {
case CompletionProposal.KEYWORD:
return createKeywordProposal(proposal);
case CompletionProposal.LIBRARY_PREFIX:
return createLibraryPrefixProposal(proposal);
case CompletionProposal.TYPE_REF:
return createTypeProposal(proposal);
// case CompletionProposal.JAVADOC_TYPE_REF:
// return createJavadocLinkTypeProposal(proposal);
case CompletionProposal.FIELD_REF:
// case CompletionProposal.JAVADOC_FIELD_REF:
// case CompletionProposal.JAVADOC_VALUE_REF:
return createFieldProposal(proposal);
// case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER:
// return createFieldWithCastedReceiverProposal(proposal);
case CompletionProposal.ARGUMENT_LIST:
case CompletionProposal.METHOD_REF:
case CompletionProposal.CONSTRUCTOR_INVOCATION:
// case CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER:
case CompletionProposal.METHOD_NAME_REFERENCE:
// case CompletionProposal.JAVADOC_METHOD_REF:
return createMethodReferenceProposal(proposal);
case CompletionProposal.METHOD_DECLARATION:
return createMethodDeclarationProposal(proposal);
// case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION:
// return createAnonymousTypeProposal(proposal, getInvocationContext());
// case CompletionProposal.ANONYMOUS_CLASS_DECLARATION:
// return createAnonymousTypeProposal(proposal, null);
case CompletionProposal.LABEL_REF:
return createLabelProposal(proposal);
case CompletionProposal.LOCAL_VARIABLE_REF:
case CompletionProposal.VARIABLE_DECLARATION:
return createLocalVariableProposal(proposal);
case CompletionProposal.TYPE_IMPORT:
return createImportProposal(proposal);
case CompletionProposal.OPTIONAL_ARGUMENT:
return new OptionalArgumentCompletionProposal(proposal);
case CompletionProposal.NAMED_ARGUMENT:
return new NamedArgumentCompletionProposal(proposal);
// case CompletionProposal.ANNOTATION_ATTRIBUTE_REF:
// return createAnnotationAttributeReferenceProposal(proposal);
// case CompletionProposal.JAVADOC_BLOCK_TAG:
// case CompletionProposal.JAVADOC_PARAM_REF:
// return createJavadocSimpleProposal(proposal);
// case CompletionProposal.JAVADOC_INLINE_TAG:
// return createJavadocInlineTagProposal(proposal);
case CompletionProposal.POTENTIAL_METHOD_DECLARATION:
default:
return null;
}
}
/**
* {@inheritDoc}
*
* <p>Subclasses may replace, but usually should not need to. Consider replacing {@linkplain
* #createDartCompletionProposal(CompletionProposal) createDartCompletionProposal} instead.
*/
@Override
public void accept(CompletionProposal proposal) {
long start = DEBUG ? System.currentTimeMillis() : 0;
try {
if (isFiltered(proposal)) {
return;
}
DartContentAssistInvocationContext ctxt = getInvocationContext();
proposal.applyPartitionOffset(ctxt.getPartitionOffset());
if (proposal.getKind() == CompletionProposal.POTENTIAL_METHOD_DECLARATION) {
acceptPotentialMethodDeclaration(proposal);
} else {
IDartCompletionProposal dartProposal = createDartCompletionProposal(proposal);
if (dartProposal != null) {
fDartProposals.add(dartProposal);
if (proposal.getKind() == CompletionProposal.KEYWORD) {
fKeywords.add(dartProposal);
}
}
}
} catch (IllegalArgumentException e) {
// all signature processing method may throw IAEs
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=84657
// don't abort, but log and show all the valid proposals
DartToolsPlugin.log(
new Status(
IStatus.ERROR,
DartToolsPlugin.getPluginId(),
IStatus.OK,
"Exception when processing proposal for: " + String.valueOf(proposal.getCompletion()),
e)); //$NON-NLS-1$
}
if (DEBUG) {
fUITime += System.currentTimeMillis() - start;
}
}
/**
* Returns the type signature of the declaring type of a <code>CompletionProposal</code>, or
* <code>null</code> for proposals that do not have a declaring type. The return value is
* <em>not</em> <code>null</code> for proposals of the following kinds:
*
* <ul>
* <li>METHOD_DECLARATION
* <li>METHOD_NAME_REFERENCE
* <li>METHOD_REF
* <li>ANNOTATION_ATTRIBUTE_REF
* <li>POTENTIAL_METHOD_DECLARATION
* <li>ANONYMOUS_CLASS_DECLARATION
* <li>FIELD_REF
* <li>PACKAGE_REF (returns the package, but no type)
* <li>TYPE_REF
* </ul>
*
* @param proposal the completion proposal to get the declaring type for
* @return the type signature of the declaring type, or <code>null</code> if there is none
*/
protected final char[] getDeclaringType(CompletionProposal proposal) {
switch (proposal.getKind()) {
case CompletionProposal.METHOD_DECLARATION:
case CompletionProposal.METHOD_NAME_REFERENCE:
// case CompletionProposal.JAVADOC_METHOD_REF:
case CompletionProposal.METHOD_REF:
case CompletionProposal.ARGUMENT_LIST:
case CompletionProposal.CONSTRUCTOR_INVOCATION:
// case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION:
// case CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER:
// case CompletionProposal.ANNOTATION_ATTRIBUTE_REF:
case CompletionProposal.POTENTIAL_METHOD_DECLARATION:
// case CompletionProposal.ANONYMOUS_CLASS_DECLARATION:
case CompletionProposal.FIELD_REF:
// case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER:
// case CompletionProposal.JAVADOC_FIELD_REF:
// case CompletionProposal.JAVADOC_VALUE_REF:
char[] declaration = proposal.getDeclarationSignature();
// special methods may not have a declaring type: methods defined on arrays etc.
// Currently known: class literals don't have a declaring type - use Object
// if (declaration == null) {
// return "java.lang.Object".toCharArray(); //$NON-NLS-1$
// }
return Signature.toCharArray(declaration);
case CompletionProposal.LIBRARY_PREFIX:
return proposal.getDeclarationSignature();
// case CompletionProposal.JAVADOC_TYPE_REF:
case CompletionProposal.TYPE_REF:
return Signature.toCharArray(proposal.getSignature());
case CompletionProposal.LOCAL_VARIABLE_REF:
case CompletionProposal.VARIABLE_DECLARATION:
case CompletionProposal.KEYWORD:
case CompletionProposal.LABEL_REF:
case CompletionProposal.TYPE_IMPORT:
case CompletionProposal.OPTIONAL_ARGUMENT:
case CompletionProposal.NAMED_ARGUMENT:
// case CompletionProposal.JAVADOC_BLOCK_TAG:
// case CompletionProposal.JAVADOC_INLINE_TAG:
// case CompletionProposal.JAVADOC_PARAM_REF:
return null;
default:
Assert.isTrue(false);
return null;
}
}
/**
* Creates the context information for a given method reference proposal. The passed proposal must
* be of kind {@link CompletionProposal#METHOD_REF}.
*
* @param methodProposal the method proposal for which to create context information
* @return the context information for <code>methodProposal</code>
*/
protected final IContextInformation createMethodContextInformation(
CompletionProposal methodProposal) {
Assert.isTrue(methodProposal.getKind() == CompletionProposal.METHOD_REF);
return new ProposalContextInformation(methodProposal);
}
