• Home
• com.vaadin
• vaadin-client-compiler-deps
• 1.0.2
• source code
• CompletionProposal.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.eclipse.jdt.core.CompletionProposal Maven / Gradle / Ivy

/*******************************************************************************
 * Copyright (c) 2004, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.internal.codeassist.InternalCompletionProposal;

/**
 * Completion proposal.
 * 

 * In typical usage, the user working in a Java code editor issues
 * a code assist command. This command results in a call to
 * ICodeAssist.codeComplete(position, completionRequestor)
 * passing the current position in the source code. The code assist
 * engine analyzes the code in the buffer, determines what kind of
 * Java language construct is at that position, and proposes ways
 * to complete that construct. These proposals are instances of
 * the class CompletionProposal. These proposals,
 * perhaps after sorting and filtering, are presented to the user
 * to make a choice.
 * 
 * 

 * The proposal is as follows: insert
 * the {@linkplain #getCompletion() completion string} into the
 * source file buffer, replacing the characters between
 * {@linkplain #getReplaceStart() the start}
 * and {@linkplain #getReplaceEnd() end}. The string
 * can be arbitrary; for example, it might include not only the
 * name of a method but a set of parentheses. Moreover, the source
 * range may include source positions before or after the source
 * position where ICodeAssist.codeComplete was invoked.
 * The rest of the information associated with the proposal is
 * to provide context that may help a user to choose from among
 * competing proposals.
 * 
 * 

 * The completion engine creates instances of this class.
 * 
 *
 * @see ICodeAssist#codeComplete(int, CompletionRequestor)
 * @since 3.0
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
public class CompletionProposal {

	/**
	 * Completion is a declaration of an anonymous class.
	 * This kind of completion might occur in a context like
	 * "new List(^;" and complete it to
	 * "new List() {}".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type being implemented or subclassed
	 * 
	 * 
{@link #getDeclarationKey()} -
	 * the type unique key of the type being implemented or subclassed
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the constructor that is referenced
	 * 
	 * 
{@link #getKey()} -
	 * the method unique key of the constructor that is referenced
	 * if the declaring type is not an interface
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the constructor that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int ANONYMOUS_CLASS_DECLARATION = 1;

	/**
	 * Completion is a reference to a field.
	 * This kind of completion might occur in a context like
	 * "this.ref^ = 0;" and complete it to
	 * "this.refcount = 0;".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int FIELD_REF = 2;

	/**
	 * Completion is a keyword.
	 * This kind of completion might occur in a context like
	 * "public cl^ Foo {}" and complete it to
	 * "public class Foo {}".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getName()} -
	 * the keyword token
	 * 
	 * 
{@link #getFlags()} -
	 * the corresponding modifier flags if the keyword is a modifier
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int KEYWORD = 3;

	/**
	 * Completion is a reference to a label.
	 * This kind of completion might occur in a context like
	 * "break lo^;" and complete it to
	 * "break loop;".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getName()} -
	 * the simple name of the label that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int LABEL_REF = 4;

	/**
	 * Completion is a reference to a local variable.
	 * This kind of completion might occur in a context like
	 * "ke^ = 4;" and complete it to
	 * "keys = 4;".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getFlags()} -
	 * the modifiers flags of the local variable that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the local variable that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the local variable's type
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int LOCAL_VARIABLE_REF = 5;

	/**
	 * Completion is a reference to a method.
	 * This kind of completion might occur in a context like
	 * "System.out.pr^();" and complete it to
	 * ""System.out.println();".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the method that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the method that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the method that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the method that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int METHOD_REF = 6;

	/**
	 * Completion is a declaration of a method.
	 * This kind of completion might occur in a context like
	 * "new List() {si^};" and complete it to
	 * "new List() {public int size() {} };".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the
	 * method that is being overridden or implemented
	 * 
	 * 
{@link #getDeclarationKey()} -
	 * the unique of the type that declares the
	 * method that is being overridden or implemented
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the method that is being overridden
	 * or implemented
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the method that is being
	 * overridden or implemented
	 * 
	 * 
{@link #getKey()} -
	 * the method unique key of the method that is being
	 * overridden or implemented
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the method that is being
	 * overridden or implemented
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int METHOD_DECLARATION = 7;

	/**
	 * Completion is a reference to a package.
	 * This kind of completion might occur in a context like
	 * "import java.u^.*;" and complete it to
	 * "import java.util.*;".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the dot-based package name of the package that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int PACKAGE_REF = 8;

	/**
	 * Completion is a reference to a type. Any kind of type
	 * is allowed, including primitive types, reference types,
	 * array types, parameterized types, and type variables.
	 * This kind of completion might occur in a context like
	 * "public static Str^ key;" and complete it to
	 * "public static String key;".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the dot-based package name of the package that contains
	 * the type that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the type that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including Flags.AccInterface, AccEnum,
	 * and AccAnnotation) of the type that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 */
	public static final int TYPE_REF = 9;

	/**
	 * Completion is a declaration of a variable (locals, parameters,
	 * fields, etc.).
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getName()} -
	 * the simple name of the variable being declared
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the type of the variable
	 * being declared
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the variable being declared
	 * 
	 * 
	 * 

	 * @see #getKind()
	 */
	public static final int VARIABLE_DECLARATION = 10;

	/**
	 * Completion is a declaration of a new potential method.
	 * This kind of completion might occur in a context like
	 * "new List() {si^};" and complete it to
	 * "new List() {public int si() {} };".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the
	 * method that is being created
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the method that is being created
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the method that is being
	 * created
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the method that is being
	 * created
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
     * @since 3.1
	 */
	public static final int POTENTIAL_METHOD_DECLARATION = 11;

	/**
	 * Completion is a reference to a method name.
	 * This kind of completion might occur in a context like
	 * "import p.X.fo^" and complete it to
	 * "import p.X.foo;".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the method that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the method that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the method that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the method that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
     * @since 3.1
	 */
	public static final int METHOD_NAME_REFERENCE = 12;

	/**
	 * Completion is a reference to annotation's attribute.
	 * This kind of completion might occur in a context like
	 * "@Annot(attr^=value)" and complete it to
	 * "@Annot(attribute^=value)".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the annotation that declares the attribute that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the attribute that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the attribute that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the attribute's type (as opposed to the
	 * signature of the type in which the referenced attribute
	 * is declared)
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.1
	 */
	public static final int ANNOTATION_ATTRIBUTE_REF = 13;

	/**
	 * Completion is a link reference to a field in a javadoc text.
	 * This kind of completion might occur in a context like
	 * "	* blabla System.o^ blabla" and complete it to
	 * "	* blabla {@link System#out } blabla".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.2
	 */
	public static final int JAVADOC_FIELD_REF = 14;

	/**
	 * Completion is a link reference to a method in a javadoc text.
	 * This kind of completion might occur in a context like
	 * "	* blabla Runtime#get^ blabla" and complete it to
	 * "	* blabla {@link Runtime#getRuntime() }".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the method that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the method that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the method that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the method that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.2
	 */
	public static final int JAVADOC_METHOD_REF = 15;

	/**
	 * Completion is a link reference to a type in a javadoc text.
	 * Any kind of type is allowed, including primitive types, reference types,
	 * array types, parameterized types, and type variables.
	 * This kind of completion might occur in a context like
	 * "	* blabla Str^ blabla" and complete it to
	 * "	* blabla {@link String } blabla".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the dot-based package name of the package that contains
	 * the type that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the type that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including Flags.AccInterface, AccEnum,
	 * and AccAnnotation) of the type that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.2
	 */
	public static final int JAVADOC_TYPE_REF = 16;

	/**
	 * Completion is a value reference to a static field in a javadoc text.
	 * This kind of completion might occur in a context like
	 * "	* blabla System.o^ blabla" and complete it to
	 * "	* blabla {@value System#out } blabla".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.2
	 */
	public static final int JAVADOC_VALUE_REF = 17;

	/**
	 * Completion is a method argument or a class/method type parameter
	 * in javadoc param tag.
	 * This kind of completion might occur in a context like
	 * "	* @param arg^ blabla" and complete it to
	 * "	* @param argument blabla".
	 * or
	 * "	* @param <T^ blabla" and complete it to
	 * "	* @param <TT> blabla".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.2
	 */
	public static final int JAVADOC_PARAM_REF = 18;

	/**
	 * Completion is a javadoc block tag.
	 * This kind of completion might occur in a context like
	 * "	* @s^ blabla" and complete it to
	 * "	* @see blabla".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.2
	 */
	public static final int JAVADOC_BLOCK_TAG = 19;

	/**
	 * Completion is a javadoc inline tag.
	 * This kind of completion might occur in a context like
	 * "	* Insert @l^ Object" and complete it to
	 * "	* Insert {@link Object }".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 * @since 3.2
	 */
	public static final int JAVADOC_INLINE_TAG = 20;

	/**
	 * Completion is an import of reference to a static field.
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is imported
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is imported
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is imported
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 * 
{@link #getAdditionalFlags()} -
	 * the completion flags (including ComletionFlags.StaticImport)
	 * of the proposed import
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 *
	 * @since 3.3
	 */
	public static final int FIELD_IMPORT = 21;

	/**
	 * Completion is an import of reference to a static method.
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the method that is imported
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the method that is imported
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the method that is imported
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the method that is imported
	 * 
	 * 
{@link #getAdditionalFlags()} -
	 * the completion flags (including ComletionFlags.StaticImport)
	 * of the proposed import
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 *
	 * @since 3.3
	 */
	public static final int METHOD_IMPORT = 22;

	/**
	 * Completion is an import of reference to a type.
	 * Only reference to reference types are allowed.
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the dot-based package name of the package that contains
	 * the type that is imported
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the type that is imported
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including Flags.AccInterface, AccEnum,
	 * and AccAnnotation) of the type that is imported
	 * 
	 * 
{@link #getAdditionalFlags()} -
	 * the completion flags (including ComletionFlags.StaticImport)
	 * of the proposed import
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 *
	 * @since 3.3
	 */
	public static final int TYPE_IMPORT = 23;

	/**
	 * Completion is a reference to a method with a casted receiver.
	 * This kind of completion might occur in a context like
	 * "receiver.fo^();" and complete it to
	 * ""((X)receiver).foo();".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the method that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the method that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the method that is referenced
	 * 
	 * 
{@link #getReceiverSignature()} -
	 * the type signature of the receiver type. It's the type of the cast expression.
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the method that is referenced
	 * 
	 * 
	 * 

	 *
	 * @see #getKind()
	 *
	 * @since 3.4
	 */
	public static final int METHOD_REF_WITH_CASTED_RECEIVER = 24;

	/**
	 * Completion is a reference to a field with a casted receiver.
	 * This kind of completion might occur in a context like
	 * "recevier.ref^ = 0;" and complete it to
	 * "((X)receiver).refcount = 0;".
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the field that is referenced
	 * 
	 * 
{@link #getReceiverSignature()} -
	 * the type signature of the receiver type. It's the type of the cast expression.
	 * 
	 * 
{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * 
	 *
	 * 
	 * 

	 *
	 * @see #getKind()
	 *
	 * @since 3.4
	 */
	public static final int FIELD_REF_WITH_CASTED_RECEIVER = 25;
	
	/**
	 * Completion is a reference to a constructor.
	 * This kind of completion might occur in a context like
	 * "new Lis" and complete it to
	 * "new List();" if List is a class that is not abstract.
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the constructor that is referenced
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the constructor that is referenced
	 * 
	 * 
{@link #getName()} -
	 * the simple name of the constructor that is referenced
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the constructor that is referenced
	 * 
	 * 
	 * 

	 * 

	 * This kind of proposal could require a long computation, so they are computed only if completion operation is called with a {@link IProgressMonitor}
	 * (e.g. {@link ICodeAssist#codeComplete(int, CompletionRequestor, IProgressMonitor)}).

	 * This kind of proposal is always is only proposals with a {@link #TYPE_REF} required proposal, so this kind of required proposal must be allowed:
	 * requestor.setAllowsRequiredProposals(CONSTRUCTOR_INVOCATION, TYPE_REF, true).
	 * 
	 *
	 * @see #getKind()
	 * @see CompletionRequestor#setAllowsRequiredProposals(int, int, boolean)
	 * 
	 * @since 3.5
	 */
	public static final int CONSTRUCTOR_INVOCATION = 26;
	
	/**
	 * Completion is a reference of a constructor of an anonymous class.
	 * This kind of completion might occur in a context like
	 * "new Lis^;" and complete it to
	 * "new List() {}" if List is an interface or abstract class.
	 * 

	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * 

	 * 
{@link #getDeclarationSignature()} -
	 * the type signature of the type being implemented or subclassed
	 * 
	 * 
{@link #getDeclarationKey()} -
	 * the type unique key of the type being implemented or subclassed
	 * 
	 * 
{@link #getSignature()} -
	 * the method signature of the constructor that is referenced
	 * 
	 * 
{@link #getKey()} -
	 * the method unique key of the constructor that is referenced
	 * if the declaring type is not an interface
	 * 
	 * 
{@link #getFlags()} -
	 * the modifiers flags of the constructor that is referenced
	 * 
	 * 
	 * 

	 * 

	 * This kind of proposal could require a long computation, so they are computed only if completion operation is called with a {@link IProgressMonitor}
	 * (e.g. {@link ICodeAssist#codeComplete(int, CompletionRequestor, IProgressMonitor)})

	 * This kind of proposal is always is only proposals with a {@link #TYPE_REF} required proposal, so this kind of required proposal must be allowed:
	 * requestor.setAllowsRequiredProposals(CONSTRUCTOR_INVOCATION, TYPE_REF, true).
	 * 
	 *
	 * @see #getKind()
	 * @see CompletionRequestor#setAllowsRequiredProposals(int, int, boolean)
	 * 
	 * @since 3.5
	 */
	public static final int ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION = 27;

	/**
	 * First valid completion kind.
	 *
	 * @since 3.1
	 */
	protected static final int FIRST_KIND = ANONYMOUS_CLASS_DECLARATION;

	/**
	 * Last valid completion kind.
	 *
	 * @since 3.1
	 */
	protected static final int LAST_KIND = ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION;

	/**
	 * Creates a basic completion proposal. All instance
	 * field have plausible default values unless otherwise noted.
	 * 

	 * Note that the constructors for this class are internal to the
	 * Java model implementation. Clients cannot directly create
	 * CompletionProposal objects.
	 * 
	 *
	 * @param kind one of the kind constants declared on this class
	 * @param completionOffset original offset of code completion request
	 * @return a new completion proposal
	 */
	public static CompletionProposal create(int kind, int completionOffset) {
		return new InternalCompletionProposal(kind, completionOffset);
	}

	/**
	 * Returns the completion flags relevant in the context, or
	 * CompletionFlags.Default if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 
FIELD_IMPORT - completion flags
	 * of the attribute that is referenced. Completion flags for
	 * this proposal kind can only include CompletionFlags.StaticImport
	 * 
METHOD_IMPORT - completion flags
	 * of the attribute that is referenced. Completion flags for
	 * this proposal kind can only include CompletionFlags.StaticImport
	 * 
TYPE_IMPORT - completion flags
	 * of the attribute that is referenced. Completion flags for
	 * this proposal kind can only include CompletionFlags.StaticImport
	 * 
	 * For other kinds of completion proposals, this method returns
	 * CompletionFlags.Default.
	 * 

	 *
	 * @return the completion flags, or
	 * CompletionFlags.Default if none
	 * @see CompletionFlags
	 *
	 * @since 3.3
	 */
	public int getAdditionalFlags() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Sets the completion flags relevant in the context.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param additionalFlags the completion flags, or
	 * CompletionFlags.Default if none
	 *
	 * @since 3.3
	 */
	public void setAdditionalFlags(int additionalFlags) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the kind of completion being proposed.
	 * 

	 * The set of different kinds of completion proposals is
	 * expected to change over time. It is strongly recommended
	 * that clients do not assume that the kind is one of the
	 * ones they know about, and code defensively for the
	 * possibility of unexpected future growth.
	 * 
	 *
	 * @return the kind; one of the kind constants
	 * declared on this class, or possibly a kind unknown
	 * to the caller
	 */
	public int getKind() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Returns the character index in the source file buffer
	 * where source completion was requested (the
	 * offset parameter to
	 * ICodeAssist.codeComplete minus one).
	 *
	 * @return character index in source file buffer
	 * @see ICodeAssist#codeComplete(int,CompletionRequestor)
	 */
	// TODO (david) https://bugs.eclipse.org/bugs/show_bug.cgi?id=132558
	public int getCompletionLocation() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Returns the character index of the start of the
	 * subrange in the source file buffer containing the
	 * relevant token being completed. This
	 * token is either the identifier or Java language keyword
	 * under, or immediately preceding, the original request
	 * offset. If the original request offset is not within
	 * or immediately after an identifier or keyword, then the
	 * position returned is original request offset and the
	 * token range is empty.
	 *
	 * @return character index of token start position (inclusive)
	 */
	public int getTokenStart() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Returns the character index of the end (exclusive) of the subrange
	 * in the source file buffer containing the
	 * relevant token. When there is no relevant token, the
	 * range is empty
	 * (getEndToken() == getStartToken()).
	 *
	 * @return character index of token end position (exclusive)
	 */
	public int getTokenEnd() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Sets the character indices of the subrange in the
	 * source file buffer containing the relevant token being
	 * completed. This token is either the identifier or
	 * Java language keyword under, or immediately preceding,
	 * the original request offset. If the original request
	 * offset is not within or immediately after an identifier
	 * or keyword, then the source range begins at original
	 * request offset and is empty.
	 * 

	 * If not set, defaults to empty subrange at [0,0).
	 * 
	 *
	 * @param startIndex character index of token start position (inclusive)
	 * @param endIndex character index of token end position (exclusive)
	 */
	public void setTokenRange(int startIndex, int endIndex) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the proposed sequence of characters to insert into the
	 * source file buffer, replacing the characters at the specified
	 * source range. The string can be arbitrary; for example, it might
	 * include not only the name of a method but a set of parentheses.
	 * 

	 * The client must not modify the array returned.
	 * 
	 *
	 * @return the completion string
	 */
	public char[] getCompletion() {
		return null; // default overridden by concrete implementation
	}

	/**
	 * Sets the proposed sequence of characters to insert into the
	 * source file buffer, replacing the characters at the specified
	 * source range. The string can be arbitrary; for example, it might
	 * include not only the name of a method but a set of parentheses.
	 * 

	 * If not set, defaults to an empty character array.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param completion the completion string
	 */
	public void setCompletion(char[] completion) {
		// default overridden by concrete implementation		
	}

	/**
	 * Returns the character index of the start of the
	 * subrange in the source file buffer to be replaced
	 * by the completion string. If the subrange is empty
	 * (getReplaceEnd() == getReplaceStart()),
	 * the completion string is to be inserted at this
	 * index.
	 * 

	 * Note that while the token subrange is precisely
	 * specified, the replacement range is loosely
	 * constrained and may not bear any direct relation
	 * to the original request offset. For example,
	 * it would be possible for a type completion to
	 * propose inserting an import declaration at the
	 * top of the compilation unit; or the completion
	 * might include trailing parentheses and
	 * punctuation for a method completion.
	 * 
	 *
	 * @return replacement start position (inclusive)
	 */
	public int getReplaceStart() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Returns the character index of the end of the
	 * subrange in the source file buffer to be replaced
	 * by the completion string. If the subrange is empty
	 * (getReplaceEnd() == getReplaceStart()),
	 * the completion string is to be inserted at this
	 * index.
	 *
	 * @return replacement end position (exclusive)
	 */
	public int getReplaceEnd() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Sets the character indices of the subrange in the
	 * source file buffer to be replaced by the completion
	 * string. If the subrange is empty
	 * (startIndex == endIndex),
	 * the completion string is to be inserted at this
	 * index.
	 * 

	 * If not set, defaults to empty subrange at [0,0).
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param startIndex character index of replacement start position (inclusive)
	 * @param endIndex character index of replacement end position (exclusive)
	 */
	public void setReplaceRange(int startIndex, int endIndex) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the relative relevance rating of this proposal.
	 *
	 * @return relevance rating of this proposal; ratings are positive; higher means better
	 */
	public int getRelevance() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Sets the relative relevance rating of this proposal.
	 * 

	 * If not set, defaults to the lowest possible rating (1).
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param rating relevance rating of this proposal; ratings are positive; higher means better
	 */
	public void setRelevance(int rating) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the type signature or package name of the relevant
	 * declaration in the context, or null if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 *  
ANNOTATION_ATTRIBUT_REF - type signature
	 * of the annotation that declares the attribute that is referenced
	 * 
ANONYMOUS_CLASS_DECLARATION - type signature
	 * of the type that is being subclassed or implemented
	 * 	
FIELD_IMPORT - type signature
	 * of the type that declares the field that is imported
	 *  
FIELD_REF - type signature
	 * of the type that declares the field that is referenced
	 *  
FIELD_REF_WITH_CASTED_RECEIVER - type signature
	 * of the type that declares the field that is referenced
	 * 	
METHOD_IMPORT - type signature
	 * of the type that declares the method that is imported
	 *  
METHOD_REF - type signature
	 * of the type that declares the method that is referenced
	 *  
METHOD_REF_WITH_CASTED_RECEIVER - type signature
	 * of the type that declares the method that is referenced
	 * 	
METHOD_DECLARATION - type signature
	 * of the type that declares the method that is being
	 * implemented or overridden
	 * 	
PACKAGE_REF - dot-based package
	 * name of the package that is referenced
	 * 	
TYPE_IMPORT - dot-based package
	 * name of the package containing the type that is imported
	 *  
TYPE_REF - dot-based package
	 * name of the package containing the type that is referenced
	 *  
POTENTIAL_METHOD_DECLARATION - type signature
	 * of the type that declares the method that is being created
	 * 
	 * For kinds of completion proposals, this method returns
	 * null. Clients must not modify the array
	 * returned.
	 * 

	 *
	 * @return a type signature or a package name (depending
	 * on the kind of completion), or null if none
	 * @see Signature
	 */
	public char[] getDeclarationSignature() {
		return null; // default overridden by concrete implementation

	}

	/**
	 * Returns the key of the relevant
	 * declaration in the context, or null if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 
ANONYMOUS_CLASS_DECLARATION - key
	 * of the type that is being subclassed or implemented
	 * 	
METHOD_DECLARATION - key
	 * of the type that declares the method that is being
	 * implemented or overridden
	 * 
	 * For kinds of completion proposals, this method returns
	 * null. Clients must not modify the array
	 * returned.
	 * 

	 *
	 * @return a key, or null if none
	 * @see org.eclipse.jdt.core.dom.ASTParser#createASTs(ICompilationUnit[], String[], org.eclipse.jdt.core.dom.ASTRequestor, IProgressMonitor)
     * @since 3.1
	 */
	public char[] getDeclarationKey() {
		return null; // default overridden by concrete implementation
	}

	/**
	 * Sets the type or package signature of the relevant
	 * declaration in the context, or null if none.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param signature the type or package signature, or
	 * null if none
	 */
	public void setDeclarationSignature(char[] signature) {
		// default overridden by concrete implementation
	}

	/**
	 * Sets the type or package key of the relevant
	 * declaration in the context, or null if none.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param key the type or package key, or
	 * null if none
     * @since 3.1
	 */
	public void setDeclarationKey(char[] key) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the simple name of the method, field,
	 * member, or variable relevant in the context, or
	 * null if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 *  
ANNOTATION_ATTRIBUT_REF - the name of the attribute
	 * 	
FIELD_IMPORT - the name of the field
	 *  
FIELD_REF - the name of the field
	 *  
FIELD_REF_WITH_CASTED_RECEIVER - the name of the field
	 * 	
KEYWORD - the keyword
	 * 	
LABEL_REF - the name of the label
	 * 	
LOCAL_VARIABLE_REF - the name of the local variable
	 * 	
METHOD_IMPORT - the name of the method
	 *  
METHOD_REF - the name of the method (the type simple name for constructor)
	 *  
METHOD_REF_WITH_CASTED_RECEIVER - the name of the method
	 * 	
METHOD_DECLARATION - the name of the method (the type simple name for constructor)
	 * 	
VARIABLE_DECLARATION - the name of the variable
	 *  
POTENTIAL_METHOD_DECLARATION - the name of the method
	 * 
	 * For kinds of completion proposals, this method returns
	 * null. Clients must not modify the array
	 * returned.
	 * 

	 *
	 * @return the keyword, field, method, local variable, or member
	 * name, or null if none
	 */
	public char[] getName() {
		return null; // default overridden by concrete implementation
	}


	/**
	 * Sets the simple name of the method (type simple name for constructor), field,
	 * member, or variable relevant in the context, or
	 * null if none.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param name the keyword, field, method, local variable,
	 * or member name, or null if none
	 */
	public void setName(char[] name) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the signature of the method or type
	 * relevant in the context, or null if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 
ANNOTATION_ATTRIBUT_REF - the type signature
	 * of the referenced attribute's type
	 * 
ANONYMOUS_CLASS_DECLARATION - method signature
	 * of the constructor that is being invoked
	 * 	
FIELD_IMPORT - the type signature
	 * of the referenced field's type
	 *  
FIELD_REF - the type signature
	 * of the referenced field's type
	 *  
FIELD_REF_WITH_CASTED_RECEIVER - the type signature
	 * of the referenced field's type
	 * 	
LOCAL_VARIABLE_REF - the type signature
	 * of the referenced local variable's type
	 * 	
METHOD_IMPORT - method signature
	 * of the method that is imported
	 *  
METHOD_REF - method signature
	 * of the method that is referenced
	 *  
METHOD_REF_WITH_CASTED_RECEIVER - method signature
	 * of the method that is referenced
	 * 	
METHOD_DECLARATION - method signature
	 * of the method that is being implemented or overridden
	 * 	
TYPE_IMPORT - type signature
	 * of the type that is imported
	 * 	
TYPE_REF - type signature
	 * of the type that is referenced
	 * 	
VARIABLE_DECLARATION - the type signature
	 * of the type of the variable being declared
	 *  
POTENTIAL_METHOD_DECLARATION - method signature
	 * of the method that is being created
	 * 
	 * For kinds of completion proposals, this method returns
	 * null. Clients must not modify the array
	 * returned.
	 * 

	 *
	 * @return the signature, or null if none
	 * @see Signature
	 */
	public char[] getSignature() {
		return null; // default overridden by concrete implementation
	}

	/**
	 * Returns the key relevant in the context,
	 * or null if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 
ANONYMOUS_CLASS_DECLARATION - method key
	 * of the constructor that is being invoked, or null if
	 * the declaring type is an interface
	 * 	
METHOD_DECLARATION - method key
	 * of the method that is being implemented or overridden
	 * 
	 * For kinds of completion proposals, this method returns
	 * null. Clients must not modify the array
	 * returned.
	 * 

	 *
	 * @return the key, or null if none
	 * @see org.eclipse.jdt.core.dom.ASTParser#createASTs(ICompilationUnit[], String[], org.eclipse.jdt.core.dom.ASTRequestor, IProgressMonitor)
     * @since 3.1
	 */
	public char[] getKey() {
		return null; // default overridden by concrete implementation
	}

	/**
	 * Sets the signature of the method, field type, member type,
	 * relevant in the context, or null if none.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param signature the signature, or null if none
	 */
	public void setSignature(char[] signature) {
		// default overridden by concrete implementation
	}

	/**
	 * Sets the key of the method, field type, member type,
	 * relevant in the context, or null if none.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param key the key, or null if none
     * @since 3.1
	 */
	public void setKey(char[] key) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the modifier flags relevant in the context, or
	 * Flags.AccDefault if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 
ANNOTATION_ATTRIBUT_REF - modifier flags
	 * of the attribute that is referenced;
	 * 
ANONYMOUS_CLASS_DECLARATION - modifier flags
	 * of the constructor that is referenced
	 * 	
FIELD_IMPORT - modifier flags
	 * of the field that is imported.
	 *  
FIELD_REF - modifier flags
	 * of the field that is referenced;
	 * Flags.AccEnum can be used to recognize
	 * references to enum constants
	 * 
	 *  
FIELD_REF_WITH_CASTED_RECEIVER - modifier flags
	 * of the field that is referenced.
	 * 
	 * 	
KEYWORD - modifier flag
	 * corresponding to the modifier keyword
	 * 	
LOCAL_VARIABLE_REF - modifier flags
	 * of the local variable that is referenced
	 *  
METHOD_IMPORT - modifier flags
	 * of the method that is imported;
	 *  
	 * 	
METHOD_REF - modifier flags
	 * of the method that is referenced;
	 * Flags.AccAnnotation can be used to recognize
	 * references to annotation type members
	 * 
	 * 
METHOD_REF_WITH_CASTED_RECEIVER - modifier flags
	 * of the method that is referenced.
	 * 
	 * 
METHOD_DECLARATION - modifier flags
	 * for the method that is being implemented or overridden
	 * 
TYPE_IMPORT - modifier flags
	 * of the type that is imported; Flags.AccInterface
	 * can be used to recognize references to interfaces,
	 * Flags.AccEnum enum types,
	 * and Flags.AccAnnotation annotation types
	 * 
TYPE_REF - modifier flags
	 * of the type that is referenced; Flags.AccInterface
	 * can be used to recognize references to interfaces,
	 * Flags.AccEnum enum types,
	 * and Flags.AccAnnotation annotation types
	 * 
	 * 	
VARIABLE_DECLARATION - modifier flags
	 * for the variable being declared
	 * 	
POTENTIAL_METHOD_DECLARATION - modifier flags
	 * for the method that is being created
	 * 
	 * For other kinds of completion proposals, this method returns
	 * Flags.AccDefault.
	 * 

	 *
	 * @return the modifier flags, or
	 * Flags.AccDefault if none
	 * @see Flags
	 */
	public int getFlags() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Sets the modifier flags relevant in the context.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param flags the modifier flags, or
	 * Flags.AccDefault if none
	 */
	public void setFlags(int flags) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the required completion proposals.
	 * The proposal can be apply only if these required completion proposals are also applied.
	 * If the required proposal aren't applied the completion could create completion problems.
	 *
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 	
FIELD_REF - The allowed required proposals for this kind are:
	 *   

	 *    
TYPE_REF
	 *    
TYPE_IMPORT
	 *    
FIELD_IMPORT
	 *   
	 * 
	 * 	
METHOD_REF - The allowed required proposals for this kind are:
	 *   

	 *    
TYPE_REF
	 *    
TYPE_IMPORT
	 *    
METHOD_IMPORT
	 *   
	 *  
	 * 
	 * 	
TYPE_REF - The allowed required proposals for this kind are:
	 *   

	 *    
TYPE_REF
	 *   
	 *  
	 *  
CONSTRUCTOR_INVOCATION - The allowed required proposals for this kind are:
	 *   

	 *    
TYPE_REF
	 *   
	 *  
	 *  
ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION - The allowed required proposals for this kind are:
	 *   

	 *    
TYPE_REF
	 *   
	 *  
	 *  
ANONYMOUS_CLASS_DECLARATION - The allowed required proposals for this kind are:
	 *   

	 *    
TYPE_REF
	 *   
	 *  
	 * 
	 * 

	 * 

	 * Other kinds of required proposals will be returned in the future, therefore clients of this
	 * API must allow with {@link CompletionRequestor#setAllowsRequiredProposals(int, int, boolean)}
	 * only kinds which are in this list to avoid unexpected results in the future.
	 * 
	 * 

	 * A required proposal of a given kind is proposed even if {@link CompletionRequestor#isIgnored(int)}
	 * return true for that kind.
	 * 
	 * 

	 * A required completion proposal cannot have required completion proposals.
	 * 
	 *
	 * @return the required completion proposals, or null if none.
	 *
	 * @see CompletionRequestor#setAllowsRequiredProposals(int, int,boolean)
	 *
	 * @since 3.3
	 */
	public CompletionProposal[] getRequiredProposals() {
		return null; // default overridden by concrete implementation
	}


	/**
	 * Sets the list of required completion proposals, or null if none.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param proposals the list of required completion proposals, or
	 * null if none
     * @since 3.3
	 */
	public void setRequiredProposals(CompletionProposal[] proposals) {
		// default overridden by concrete implementation
	}

	/**
	 * Finds the method parameter names.
	 * This information is relevant to method reference (and
	 * method declaration proposals). Returns null
	 * if not available or not relevant.
	 * 

	 * The client must not modify the array returned.
	 * 
	 * 

	 * Note that this is an expensive thing to compute, which may require
	 * parsing Java source files, etc. Use sparingly.
	 * 
	 *
	 * @param monitor the progress monitor, or null if none
	 * @return the parameter names, or null if none
	 * or not available or not relevant
	 */
	public char[][] findParameterNames(IProgressMonitor monitor) {
		return null; // default overridden by concrete implementation
	}

	/**
	 * Sets the method parameter names.
	 * This information is relevant to method reference (and
	 * method declaration proposals).
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param parameterNames the parameter names, or null if none
	 */
	public void setParameterNames(char[][] parameterNames) {
		// default overridden by concrete implementation
	}

	/**
	 * Returns the accessibility of the proposal.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 	
TYPE_REF - accessibility of the type
	 * 
	 * For these kinds of completion proposals, this method returns
	 * {@link IAccessRule#K_ACCESSIBLE} or {@link IAccessRule#K_DISCOURAGED}
	 * or {@link IAccessRule#K_NON_ACCESSIBLE}.
	 * By default this method return {@link IAccessRule#K_ACCESSIBLE}.
	 * 

	 *
	 * @see IAccessRule
	 *
	 * @return the accessibility of the proposal
	 *
	 * @since 3.1
	 */
	public int getAccessibility() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Returns whether this proposal is a constructor.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 * 
METHOD_REF - return true
	 * if the referenced method is a constructor
	 * 	
METHOD_DECLARATION - return true
	 * if the declared method is a constructor
	 * 
	 * For kinds of completion proposals, this method returns
	 * false.
	 * 

	 *
	 * @return true if the proposal is a constructor.
	 * @since 3.1
	 */
	public boolean isConstructor() {
		return false; // default overridden by concrete implementation
	}

	/**
	 * Returns the type signature or package name of the relevant
	 * receiver in the context, or null if none.
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 *  
FIELD_REF_WITH_CASTED_RECEIVER - type signature
	 * of the type that cast the receiver of the field that is referenced
	 *  
METHOD_REF_WITH_CASTED_RECEIVER - type signature
	 * of the type that cast the receiver of the method that is referenced
	 * 
	 * For kinds of completion proposals, this method returns
	 * null. Clients must not modify the array
	 * returned.
	 * 

	 *
	 * @return a type signature or a package name (depending
	 * on the kind of completion), or null if none
	 * @see Signature
	 *
	 * @since 3.4
	 */
	public char[] getReceiverSignature() {
		return null; // default overridden by concrete implementation
	}

	/**
	 * Returns the character index of the start of the
	 * subrange in the source file buffer containing the
	 * relevant receiver of the member being completed. This
	 * receiver is an expression.
	 *
	 * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 *  
FIELD_REF_WITH_CASTED_RECEIVER
	 *  
METHOD_REF_WITH_CASTED_RECEIVER
	 * 
	 * For kinds of completion proposals, this method returns 0.
	 * 

	 *
	 * @return character index of receiver start position (inclusive)
	 *
	 * @since 3.4
	 */
	public int getReceiverStart() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Returns the character index of the end (exclusive) of the subrange
	 * in the source file buffer containing the
	 * relevant receiver of the member being completed.
	 *
	 * * 

	 * This field is available for the following kinds of
	 * completion proposals:
	 * 

	 *  
FIELD_REF_WITH_CASTED_RECEIVER
	 *  
METHOD_REF_WITH_CASTED_RECEIVER
	 * 
	 * For kinds of completion proposals, this method returns 0.
	 * 

	 *
	 * @return character index of receiver end position (exclusive)
	 *
	 * @since 3.4
	 */
	public int getReceiverEnd() {
		return -1; // default overridden by concrete implementation
	}

	/**
	 * Sets the type or package signature of the relevant
	 * receiver in the context, or null if none.
	 * 

	 * If not set, defaults to none.
	 * 
	 * 

	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * 
	 *
	 * @param signature the type or package signature, or
	 * null if none
	 *
	 * @since 3.4
	 */
	public void setReceiverSignature(char[] signature) {
		// default overridden by concrete implementation
	}

	/**
	 * Sets the character indices of the subrange in the
	 * source file buffer containing the relevant receiver
	 * of the member being completed.
	 *
	 * 

	 * If not set, defaults to empty subrange at [0,0).
	 * 
	 *
	 * @param startIndex character index of receiver start position (inclusive)
	 * @param endIndex character index of receiver end position (exclusive)
	 *
	 * @since 3.4
	 */
	public void setReceiverRange(int startIndex, int endIndex) {
		// default overridden by concrete implementation
	}

	/** 
	 * Returns whether it is safe to use the '<>' (diamond) operator in place of explicitly specifying
	 * type arguments for this proposal.
	 * 
	 * 

	 * This is only relevant for source level 1.7 or greater.
	 * 
	 * 
	 * @param coreContext the completion context associated with the proposal
	 * @since 3.7.1
	 * @return true if it is safe to use the diamond operator for the constructor invocation, 
	 * false otherwise. Also returns false for source levels below 1.7
	 */
	public boolean canUseDiamond(CompletionContext coreContext) {
		return false; // default overridden by concrete implementation
	}
}