| /******************************************************************************* |
| * 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); |
| } |
| } |