/*******************************************************************************
* Copyright (c) 2008, 2009 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.internal.codeassist;
import java.util.Map;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnAnnotationOfType;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnArgumentName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldType;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnImportReference;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnKeyword;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnKeyword2;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMethodName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMethodReturnType;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMethodTypeParameter;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnPackageReference;
import org.eclipse.jdt.internal.compiler.SourceElementNotifier;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt;
public class CompletionElementNotifier extends SourceElementNotifier {
private ASTNode assistNode;
public CompletionElementNotifier(
CompletionUnitStructureRequestor requestor,
boolean reportLocalDeclarations,
ASTNode assistNode) {
super(requestor, reportLocalDeclarations);
this.assistNode = assistNode;
}
protected char[][][] getArguments(Argument[] arguments) {
int argumentLength = arguments.length;
char[][] argumentTypes = new char[argumentLength][];
char[][] argumentNames = new char[argumentLength][];
int argumentCount = 0;
next : for (int i = 0; i < argumentLength; i++) {
Argument argument = arguments[i];
if (argument instanceof CompletionOnArgumentName && argument.name.length == 0) continue next;
argumentTypes[argumentCount] = CharOperation.concatWith(argument.type.getParameterizedTypeName(), '.');
argumentNames[argumentCount++] = argument.name;
}
if (argumentCount < argumentLength) {
System.arraycopy(argumentTypes, 0, argumentTypes = new char[argumentCount][], 0, argumentCount);
System.arraycopy(argumentNames, 0, argumentNames = new char[argumentCount][], 0, argumentCount);
}
return new char[][][] {argumentTypes, argumentNames};
}
protected char[][] getInterfaceNames(TypeDeclaration typeDeclaration) {
char[][] interfaceNames = null;
int superInterfacesLength = 0;
TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
if (superInterfaces != null) {
superInterfacesLength = superInterfaces.length;
interfaceNames = new char[superInterfacesLength][];
} else {
if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
// see PR 3442
QualifiedAllocationExpression alloc = typeDeclaration.allocation;
if (alloc != null && alloc.type != null) {
superInterfaces = new TypeReference[] { alloc.type};
superInterfacesLength = 1;
interfaceNames = new char[1][];
}
}
}
if (superInterfaces != null) {
int superInterfaceCount = 0;
next: for (int i = 0; i < superInterfacesLength; i++) {
TypeReference superInterface = superInterfaces[i];
if (superInterface instanceof CompletionOnKeyword) continue next;
if (CompletionUnitStructureRequestor.hasEmptyName(superInterface, this.assistNode)) continue next;
interfaceNames[superInterfaceCount++] = CharOperation.concatWith(superInterface.getParameterizedTypeName(), '.');
}
if (superInterfaceCount == 0) return null;
if (superInterfaceCount < superInterfacesLength) {
System.arraycopy(interfaceNames, 0, interfaceNames = new char[superInterfaceCount][], 0, superInterfaceCount);
}
}
return interfaceNames;
}
protected char[] getSuperclassName(TypeDeclaration typeDeclaration) {
TypeReference superclass = typeDeclaration.superclass;
if (superclass instanceof CompletionOnKeyword) return null;
if (CompletionUnitStructureRequestor.hasEmptyName(superclass, this.assistNode)) return null;
return superclass != null ? CharOperation.concatWith(superclass.getParameterizedTypeName(), '.') : null;
}
protected char[][] getThrownExceptions(AbstractMethodDeclaration methodDeclaration) {
char[][] thrownExceptionTypes = null;
TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
if (thrownExceptions != null) {
int thrownExceptionLength = thrownExceptions.length;
int thrownExceptionCount = 0;
thrownExceptionTypes = new char[thrownExceptionLength][];
next : for (int i = 0; i < thrownExceptionLength; i++) {
TypeReference thrownException = thrownExceptions[i];
if (thrownException instanceof CompletionOnKeyword) continue next;
if (CompletionUnitStructureRequestor.hasEmptyName(thrownException, this.assistNode)) continue next;
thrownExceptionTypes[thrownExceptionCount++] =
CharOperation.concatWith(thrownException.getParameterizedTypeName(), '.');
}
if (thrownExceptionCount == 0) return null;
if (thrownExceptionCount < thrownExceptionLength) {
System.arraycopy(thrownExceptionTypes, 0, thrownExceptionTypes = new char[thrownExceptionCount][], 0, thrownExceptionCount);
}
}
return thrownExceptionTypes;
}
protected char[][] getTypeParameterBounds(TypeParameter typeParameter) {
TypeReference firstBound = typeParameter.type;
TypeReference[] otherBounds = typeParameter.bounds;
char[][] typeParameterBounds = null;
if (firstBound != null) {
if (otherBounds != null) {
int otherBoundsLength = otherBounds.length;
char[][] boundNames = new char[otherBoundsLength+1][];
int boundCount = 0;
if (!CompletionUnitStructureRequestor.hasEmptyName(firstBound, this.assistNode)) {
boundNames[boundCount++] = CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.');
}
for (int j = 0; j < otherBoundsLength; j++) {
TypeReference otherBound = otherBounds[j];
if (!CompletionUnitStructureRequestor.hasEmptyName(otherBound, this.assistNode)) {
boundNames[boundCount++] =
CharOperation.concatWith(otherBound.getParameterizedTypeName(), '.');
}
}
if (boundCount == 0) {
boundNames = CharOperation.NO_CHAR_CHAR;
} else if (boundCount < otherBoundsLength + 1){
System.arraycopy(boundNames, 0, boundNames = new char[boundCount][], 0, boundCount);
}
typeParameterBounds = boundNames;
} else {
if (!CompletionUnitStructureRequestor.hasEmptyName(firstBound, this.assistNode)) {
typeParameterBounds = new char[][] { CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.')};
} else {
typeParameterBounds = CharOperation.NO_CHAR_CHAR;
}
}
} else {
typeParameterBounds = CharOperation.NO_CHAR_CHAR;
}
return typeParameterBounds;
}
protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration, TypeDeclaration declaringType, ImportReference currentPackage) {
if (methodDeclaration instanceof CompletionOnMethodReturnType) return;
if (methodDeclaration instanceof CompletionOnMethodTypeParameter) return;
if (methodDeclaration instanceof CompletionOnMethodName) return;
super.notifySourceElementRequestor(methodDeclaration, declaringType, currentPackage);
}
public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit, int sourceStart, int sourceEnd, boolean reportReference, HashtableOfObjectToInt sourceEndsMap, Map nodesToCategoriesMap) {
super.notifySourceElementRequestor(parsedUnit, sourceStart, sourceEnd, reportReference, sourceEndsMap, nodesToCategoriesMap);
}
protected void notifySourceElementRequestor(FieldDeclaration fieldDeclaration, TypeDeclaration declaringType) {
if (fieldDeclaration instanceof CompletionOnFieldType) return;
if (fieldDeclaration instanceof CompletionOnFieldName) return;
super.notifySourceElementRequestor(fieldDeclaration, declaringType);
}
protected void notifySourceElementRequestor(ImportReference importReference, boolean isPackage) {
if (importReference instanceof CompletionOnKeyword2) return;
if (importReference instanceof CompletionOnImportReference ||
importReference instanceof CompletionOnPackageReference) {
if (importReference.tokens[importReference.tokens.length - 1].length == 0) return;
}
super.notifySourceElementRequestor(importReference, isPackage);
}
protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType, ImportReference currentPackage) {
if (typeDeclaration instanceof CompletionOnAnnotationOfType) return;
super.notifySourceElementRequestor(typeDeclaration, notifyTypePresence, declaringType, currentPackage);
}
}