| /******************************************************************************* |
| * Copyright (c) 2016 Google, Inc 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: |
| * Stefan Xenos (Google) - Initial implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.core.nd.indexer; |
| |
| import java.lang.reflect.Modifier; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.jdt.core.IClassFile; |
| import org.eclipse.jdt.core.compiler.CharOperation; |
| import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException; |
| import org.eclipse.jdt.internal.compiler.codegen.AnnotationTargetTypeConstants; |
| import org.eclipse.jdt.internal.compiler.env.ClassSignature; |
| import org.eclipse.jdt.internal.compiler.env.EnumConstantSignature; |
| import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation; |
| import org.eclipse.jdt.internal.compiler.env.IBinaryElementValuePair; |
| import org.eclipse.jdt.internal.compiler.env.IBinaryField; |
| import org.eclipse.jdt.internal.compiler.env.IBinaryMethod; |
| import org.eclipse.jdt.internal.compiler.env.IBinaryType; |
| import org.eclipse.jdt.internal.compiler.env.IBinaryTypeAnnotation; |
| import org.eclipse.jdt.internal.compiler.impl.Constant; |
| import org.eclipse.jdt.internal.compiler.lookup.SignatureWrapper; |
| import org.eclipse.jdt.internal.core.JarPackageFragmentRoot; |
| import org.eclipse.jdt.internal.core.JavaModelManager; |
| import org.eclipse.jdt.internal.core.Openable; |
| import org.eclipse.jdt.internal.core.PackageFragment; |
| import org.eclipse.jdt.internal.core.nd.Nd; |
| import org.eclipse.jdt.internal.core.nd.db.IndexException; |
| import org.eclipse.jdt.internal.core.nd.java.JavaIndex; |
| import org.eclipse.jdt.internal.core.nd.java.JavaNames; |
| import org.eclipse.jdt.internal.core.nd.java.NdAnnotation; |
| import org.eclipse.jdt.internal.core.nd.java.NdAnnotationInConstant; |
| import org.eclipse.jdt.internal.core.nd.java.NdAnnotationInMethod; |
| import org.eclipse.jdt.internal.core.nd.java.NdAnnotationInMethodParameter; |
| import org.eclipse.jdt.internal.core.nd.java.NdAnnotationInType; |
| import org.eclipse.jdt.internal.core.nd.java.NdAnnotationInVariable; |
| import org.eclipse.jdt.internal.core.nd.java.NdAnnotationValuePair; |
| import org.eclipse.jdt.internal.core.nd.java.NdBinding; |
| import org.eclipse.jdt.internal.core.nd.java.NdComplexTypeSignature; |
| import org.eclipse.jdt.internal.core.nd.java.NdConstant; |
| import org.eclipse.jdt.internal.core.nd.java.NdConstantAnnotation; |
| import org.eclipse.jdt.internal.core.nd.java.NdConstantArray; |
| import org.eclipse.jdt.internal.core.nd.java.NdConstantClass; |
| import org.eclipse.jdt.internal.core.nd.java.NdConstantEnum; |
| import org.eclipse.jdt.internal.core.nd.java.NdMethod; |
| import org.eclipse.jdt.internal.core.nd.java.NdMethodException; |
| import org.eclipse.jdt.internal.core.nd.java.NdMethodId; |
| import org.eclipse.jdt.internal.core.nd.java.NdMethodParameter; |
| import org.eclipse.jdt.internal.core.nd.java.NdResourceFile; |
| import org.eclipse.jdt.internal.core.nd.java.NdType; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeAnnotation; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeAnnotationInMethod; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeAnnotationInType; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeAnnotationInVariable; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeArgument; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeBound; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeId; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeInterface; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeParameter; |
| import org.eclipse.jdt.internal.core.nd.java.NdTypeSignature; |
| import org.eclipse.jdt.internal.core.nd.java.NdVariable; |
| import org.eclipse.jdt.internal.core.nd.java.model.BinaryTypeDescriptor; |
| import org.eclipse.jdt.internal.core.nd.java.model.BinaryTypeFactory; |
| import org.eclipse.jdt.internal.core.nd.util.CharArrayUtils; |
| import org.eclipse.jdt.internal.core.util.CharArrayBuffer; |
| import org.eclipse.jdt.internal.core.util.Util; |
| |
| public final class ClassFileToIndexConverter { |
| private static final char[] JAVA_LANG_OBJECT_FIELD_DESCRIPTOR = "Ljava/lang/Object;".toCharArray(); //$NON-NLS-1$ |
| private static final char[] INNER_TYPE_SEPARATOR = new char[] { '$' }; |
| private static final char[] FIELD_DESCRIPTOR_SUFFIX = new char[] { ';' }; |
| private static final char[] COMMA = new char[]{','}; |
| private static final char[][] EMPTY_CHAR_ARRAY_ARRAY = new char[0][]; |
| private static final boolean ENABLE_LOGGING = false; |
| private static final char[] EMPTY_CHAR_ARRAY = new char[0]; |
| private static final char[] PATH_SEPARATOR = new char[]{'/'}; |
| private static final char[] ARRAY_FIELD_DESCRIPTOR_PREFIX = new char[] { '[' }; |
| private NdResourceFile resource; |
| private JavaIndex index; |
| |
| public ClassFileToIndexConverter(NdResourceFile resourceFile) { |
| this.resource = resourceFile; |
| this.index = JavaIndex.getIndex(resourceFile.getNd()); |
| } |
| |
| private Nd getNd() { |
| return this.resource.getNd(); |
| } |
| |
| public static IBinaryType getTypeFromClassFile(IClassFile iClassFile, IProgressMonitor monitor) |
| throws CoreException, ClassFormatException { |
| BinaryTypeDescriptor descriptor = BinaryTypeFactory.createDescriptor(iClassFile); |
| return BinaryTypeFactory.rawReadType(descriptor, true); |
| } |
| |
| /** |
| * Create a type info from the given class file in a jar and adds it to the given list of infos. |
| * |
| * @throws CoreException |
| */ |
| protected static IBinaryType createInfoFromClassFileInJar(Openable classFile) throws CoreException { |
| PackageFragment pkg = (PackageFragment) classFile.getParent(); |
| String classFilePath = Util.concatWith(pkg.names, classFile.getElementName(), '/'); |
| IBinaryType info = null; |
| java.util.zip.ZipFile zipFile = null; |
| try { |
| zipFile = ((JarPackageFragmentRoot) pkg.getParent()).getJar(); |
| info = org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader.read(zipFile, classFilePath); |
| } catch (Exception e) { |
| throw new CoreException(Package.createStatus("Unable to parse JAR file", e)); //$NON-NLS-1$ |
| } finally { |
| JavaModelManager.getJavaModelManager().closeZipFile(zipFile); |
| } |
| return info; |
| } |
| |
| /** |
| * Adds a type to the index, given an input class file and a binary name. Note that the given binary name is |
| * |
| * @param binaryType an object used for parsing the .class file itself |
| * @param fieldDescriptor the name that is used to locate the class, computed from the .class file's name and location. |
| * In the event that the .class file has been moved, this may differ from the binary name stored in the .class file |
| * itself, which is why this is received as an argument rather than extracted from the .class file. |
| * @throws CoreException |
| */ |
| public NdType addType(IBinaryType binaryType, char[] fieldDescriptor, IProgressMonitor monitor) throws CoreException { |
| char[] fieldDescriptorFromClass = JavaNames.binaryNameToFieldDescriptor(binaryType.getName()); |
| logInfo("adding binary type " + new String(fieldDescriptor)); //$NON-NLS-1$ |
| |
| NdTypeId name = createTypeIdFromFieldDescriptor(fieldDescriptor); |
| NdType type = name.findTypeByResourceAddress(this.resource.address); |
| |
| if (type == null) { |
| type = new NdType(getNd(), this.resource); |
| } |
| |
| IBinaryTypeAnnotation[] typeAnnotations = binaryType.getTypeAnnotations(); |
| if (typeAnnotations != null) { |
| for (IBinaryTypeAnnotation typeAnnotation : typeAnnotations) { |
| NdTypeAnnotationInType annotation = new NdTypeAnnotationInType(getNd(), type); |
| |
| initTypeAnnotation(annotation, typeAnnotation); |
| } |
| } |
| |
| type.setTypeId(name); |
| |
| if (!CharArrayUtils.equals(fieldDescriptorFromClass, fieldDescriptor)) { |
| type.setFieldDescriptorFromClass(fieldDescriptorFromClass); |
| } |
| |
| char[][] interfaces = binaryType.getInterfaceNames(); |
| if (interfaces == null) { |
| interfaces = EMPTY_CHAR_ARRAY_ARRAY; |
| } |
| |
| if (binaryType.getGenericSignature() != null) { |
| type.setFlag(NdType.FLG_GENERIC_SIGNATURE_PRESENT, true); |
| } |
| |
| // Create the default generic signature if the .class file didn't supply one |
| SignatureWrapper signatureWrapper = GenericSignatures.getGenericSignature(binaryType); |
| |
| type.setModifiers(binaryType.getModifiers()); |
| type.setDeclaringType(createTypeIdFromBinaryName(binaryType.getEnclosingTypeName())); |
| |
| readTypeParameters(type, signatureWrapper); |
| |
| char[] superclassFieldDescriptor; |
| char[] superclassBinaryName = binaryType.getSuperclassName(); |
| if (superclassBinaryName == null) { |
| superclassFieldDescriptor = JAVA_LANG_OBJECT_FIELD_DESCRIPTOR; |
| } else { |
| superclassFieldDescriptor = JavaNames.binaryNameToFieldDescriptor(superclassBinaryName); |
| } |
| type.setSuperclass(createTypeSignature(signatureWrapper, superclassFieldDescriptor)); |
| |
| short interfaceIdx = 0; |
| while (signatureWrapper.start < signatureWrapper.signature.length) { |
| // Note that there may be more interfaces listed in the generic signature than in the interfaces list. |
| // Although the VM spec doesn't discuss this case specifically, there are .class files in the wild with |
| // this characteristic. In such cases, we take what's in the generic signature and discard what's in the |
| // interfaces list. |
| char[] interfaceSpec = interfaceIdx < interfaces.length ? interfaces[interfaceIdx] : EMPTY_CHAR_ARRAY; |
| new NdTypeInterface(getNd(), type, |
| createTypeSignature(signatureWrapper, JavaNames.binaryNameToFieldDescriptor(interfaceSpec))); |
| interfaceIdx++; |
| } |
| |
| IBinaryAnnotation[] annotations = binaryType.getAnnotations(); |
| attachAnnotations(type, annotations); |
| |
| type.setDeclaringMethod(createMethodId(binaryType.getEnclosingTypeName(), binaryType.getEnclosingMethod())); |
| |
| IBinaryField[] fields = binaryType.getFields(); |
| |
| if (fields != null) { |
| for (IBinaryField nextField : fields) { |
| addField(type, nextField); |
| } |
| } |
| |
| IBinaryMethod[] methods = binaryType.getMethods(); |
| |
| if (methods != null) { |
| for (IBinaryMethod next : methods) { |
| addMethod(type, next, binaryType); |
| } |
| } |
| |
| char[][][] missingTypeNames = binaryType.getMissingTypeNames(); |
| char[] missingTypeString = getMissingTypeString(missingTypeNames); |
| |
| type.setMissingTypeNames(missingTypeString); |
| type.setSourceFileName(binaryType.sourceFileName()); |
| type.setAnonymous(binaryType.isAnonymous()); |
| type.setIsLocal(binaryType.isLocal()); |
| type.setIsMember(binaryType.isMember()); |
| type.setTagBits(binaryType.getTagBits()); |
| type.setSourceNameOverride(binaryType.getSourceName()); |
| |
| return type; |
| } |
| |
| private static char[] getMissingTypeString(char[][][] missingTypeNames) { |
| char[] missingTypeString = null; |
| if (missingTypeNames != null) { |
| CharArrayBuffer builder = new CharArrayBuffer(); |
| for (int typeIdx = 0; typeIdx < missingTypeNames.length; typeIdx++) { |
| char[][] next = missingTypeNames[typeIdx]; |
| if (typeIdx != 0) { |
| builder.append(COMMA); |
| } |
| if (next == null) { |
| continue; |
| } |
| for (int segmentIdx = 0; segmentIdx < next.length; segmentIdx++) { |
| char[] segment = next[segmentIdx]; |
| if (segment == null) { |
| continue; |
| } |
| if (segmentIdx != 0) { |
| builder.append(PATH_SEPARATOR); |
| } |
| builder.append(segment); |
| } |
| } |
| missingTypeString = builder.getContents(); |
| } |
| return missingTypeString; |
| } |
| |
| private void attachAnnotations(NdMethod method, IBinaryAnnotation[] annotations) { |
| if (annotations != null) { |
| for (IBinaryAnnotation next : annotations) { |
| NdAnnotationInMethod annotation = new NdAnnotationInMethod(getNd(), method); |
| initAnnotation(annotation, next); |
| } |
| } |
| } |
| |
| private void attachAnnotations(NdType type, IBinaryAnnotation[] annotations) { |
| if (annotations != null) { |
| for (IBinaryAnnotation next : annotations) { |
| NdAnnotationInType annotation = new NdAnnotationInType(getNd(), type); |
| initAnnotation(annotation, next); |
| } |
| } |
| } |
| |
| private void attachAnnotations(NdVariable variable, IBinaryAnnotation[] annotations) { |
| if (annotations != null) { |
| for (IBinaryAnnotation next : annotations) { |
| NdAnnotationInVariable annotation = new NdAnnotationInVariable(getNd(), variable); |
| initAnnotation(annotation, next); |
| } |
| } |
| } |
| |
| private void attachAnnotations(NdMethodParameter variable, IBinaryAnnotation[] annotations) { |
| if (annotations != null) { |
| for (IBinaryAnnotation next : annotations) { |
| NdAnnotationInMethodParameter annotation = new NdAnnotationInMethodParameter(getNd(), variable); |
| initAnnotation(annotation, next); |
| } |
| } |
| } |
| |
| /** |
| * Adds the given method to the given type |
| * |
| * @throws CoreException |
| */ |
| private void addMethod(NdType type, IBinaryMethod next, IBinaryType binaryType) |
| throws CoreException { |
| int flags = 0; |
| NdMethod method = new NdMethod(type); |
| |
| attachAnnotations(method, next.getAnnotations()); |
| |
| if (next.getGenericSignature() != null) { |
| flags |= NdMethod.FLG_GENERIC_SIGNATURE_PRESENT; |
| } |
| SignatureWrapper signature = GenericSignatures.getGenericSignature(next); |
| SignatureWrapper descriptor = new SignatureWrapper(next.getMethodDescriptor()); |
| readTypeParameters(method, signature); |
| |
| IBinaryTypeAnnotation[] typeAnnotations = next.getTypeAnnotations(); |
| if (typeAnnotations != null) { |
| for (IBinaryTypeAnnotation typeAnnotation : typeAnnotations) { |
| NdTypeAnnotationInMethod annotation = new NdTypeAnnotationInMethod(getNd(), method); |
| |
| initTypeAnnotation(annotation, typeAnnotation); |
| } |
| } |
| |
| skipChar(signature, '('); |
| skipChar(descriptor, '('); |
| |
| List<char[]> parameterFieldDescriptors = new ArrayList<>(); |
| while (!descriptor.atEnd()) { |
| if (descriptor.charAtStart() == ')') { |
| skipChar(descriptor, ')'); |
| break; |
| } |
| parameterFieldDescriptors.add(readNextFieldDescriptor(descriptor)); |
| } |
| |
| char[][] parameterNames = next.getArgumentNames(); |
| int numArgumentsInGenericSignature = countMethodArguments(signature); |
| int numCompilerDefinedParameters = Math.max(0, |
| parameterFieldDescriptors.size() - numArgumentsInGenericSignature); |
| |
| boolean compilerDefinedParametersAreIncludedInSignature = (next.getGenericSignature() == null); |
| |
| // If there is no generic signature, then fall back to heuristics based on what we know about |
| // where the java compiler likes to create compiler-defined arguments |
| if (compilerDefinedParametersAreIncludedInSignature) { |
| // Constructors for non-static member types get a compiler-defined first argument |
| if (binaryType.isMember() |
| && next.isConstructor() |
| && ((binaryType.getModifiers() & Modifier.STATIC) == 0) |
| && parameterFieldDescriptors.size() > 0) { |
| |
| numCompilerDefinedParameters = 1; |
| } else { |
| numCompilerDefinedParameters = 0; |
| } |
| } |
| |
| int parameterNameIdx = 0; |
| int annotatedParametersCount = next.getAnnotatedParametersCount(); |
| |
| short descriptorParameterIdx = 0; |
| char[] binaryTypeName = binaryType.getName(); |
| while (!signature.atEnd()) { |
| if (signature.charAtStart() == ')') { |
| skipChar(signature, ')'); |
| break; |
| } |
| char[] nextFieldDescriptor = parameterFieldDescriptors.get(descriptorParameterIdx); |
| /** |
| * True iff this a parameter which is part of the field descriptor but not the generic signature -- that is, |
| * it is a compiler-defined parameter. |
| */ |
| boolean isCompilerDefined = descriptorParameterIdx < numCompilerDefinedParameters; |
| SignatureWrapper nextFieldSignature = signature; |
| if (isCompilerDefined && !compilerDefinedParametersAreIncludedInSignature) { |
| nextFieldSignature = new SignatureWrapper(nextFieldDescriptor); |
| } |
| NdMethodParameter parameter = new NdMethodParameter(method, |
| createTypeSignature(nextFieldSignature, nextFieldDescriptor)); |
| |
| parameter.setCompilerDefined(isCompilerDefined); |
| |
| if (descriptorParameterIdx < annotatedParametersCount) { |
| IBinaryAnnotation[] parameterAnnotations = next.getParameterAnnotations(descriptorParameterIdx, |
| binaryTypeName); |
| |
| attachAnnotations(parameter, parameterAnnotations); |
| } |
| if (!isCompilerDefined && parameterNames != null && parameterNames.length > parameterNameIdx) { |
| parameter.setName(parameterNames[parameterNameIdx++]); |
| } |
| descriptorParameterIdx++; |
| } |
| |
| skipChar(descriptor, ')'); |
| char[] nextFieldDescriptor = readNextFieldDescriptor(descriptor); |
| method.setReturnType(createTypeSignature(signature, nextFieldDescriptor)); |
| |
| boolean hasExceptionsInSignature = hasAnotherException(signature); |
| char[][] exceptionTypes = next.getExceptionTypeNames(); |
| if (exceptionTypes == null) { |
| exceptionTypes = CharArrayUtils.EMPTY_ARRAY_OF_CHAR_ARRAYS; |
| } |
| int throwsIdx = 0; |
| if (hasExceptionsInSignature) { |
| while (hasAnotherException(signature)) { |
| signature.start++; |
| new NdMethodException(method, createTypeSignature(signature, |
| JavaNames.binaryNameToFieldDescriptor(exceptionTypes[throwsIdx]))); |
| throwsIdx++; |
| } |
| } else if (exceptionTypes.length != 0) { |
| for (;throwsIdx < exceptionTypes.length; throwsIdx++) { |
| char[] fieldDescriptor = JavaNames.binaryNameToFieldDescriptor(exceptionTypes[throwsIdx]); |
| SignatureWrapper convertedWrapper = new SignatureWrapper(fieldDescriptor); |
| new NdMethodException(method, createTypeSignature(convertedWrapper, |
| JavaNames.binaryNameToFieldDescriptor(exceptionTypes[throwsIdx]))); |
| } |
| } |
| |
| if (hasExceptionsInSignature) { |
| flags |= NdMethod.FLG_THROWS_SIGNATURE_PRESENT; |
| } |
| |
| Object defaultValue = next.getDefaultValue(); |
| if (defaultValue != null) { |
| method.setDefaultValue(createConstantFromMixedType(defaultValue)); |
| } |
| |
| method.setMethodId(createMethodId(binaryType.getName(), next.getSelector(), next.getMethodDescriptor())); |
| method.setModifiers(next.getModifiers()); |
| method.setTagBits(next.getTagBits()); |
| method.setFlags(flags); |
| } |
| |
| private boolean hasAnotherException(SignatureWrapper signature) { |
| return !signature.atEnd() && signature.charAtStart() == '^'; |
| } |
| |
| private void skipChar(SignatureWrapper signature, char toSkip) { |
| if (signature.start < signature.signature.length && signature.charAtStart() == toSkip) { |
| signature.start++; |
| } |
| } |
| |
| /** |
| * Adds the given field to the given type |
| */ |
| private void addField(NdType type, IBinaryField nextField) throws CoreException { |
| NdVariable variable = new NdVariable(type); |
| |
| variable.setName(nextField.getName()); |
| |
| if (nextField.getGenericSignature() != null) { |
| variable.setVariableFlag(NdVariable.FLG_GENERIC_SIGNATURE_PRESENT); |
| } |
| |
| attachAnnotations(variable, nextField.getAnnotations()); |
| |
| variable.setConstant(NdConstant.create(getNd(), nextField.getConstant())); |
| variable.setModifiers(nextField.getModifiers()); |
| SignatureWrapper nextTypeSignature = GenericSignatures.getGenericSignatureFor(nextField); |
| |
| IBinaryTypeAnnotation[] typeAnnotations = nextField.getTypeAnnotations(); |
| if (typeAnnotations != null) { |
| for (IBinaryTypeAnnotation next : typeAnnotations) { |
| NdTypeAnnotationInVariable annotation = new NdTypeAnnotationInVariable(getNd(), variable); |
| |
| initTypeAnnotation(annotation, next); |
| } |
| } |
| variable.setType(createTypeSignature(nextTypeSignature, nextField.getTypeName())); |
| variable.setTagBits(nextField.getTagBits()); |
| |
| // char[] fieldDescriptor = nextField.getTypeName(); |
| // // DO NOT SUBMIT: |
| // IBinaryField bf = IndexBinaryType.createBinaryField(variable); |
| } |
| |
| /** |
| * Reads and attaches any generic type parameters at the current start position in the given wrapper. Sets |
| * wrapper.start to the character following the type parameters. |
| * |
| * @throws CoreException |
| */ |
| private void readTypeParameters(NdBinding type, SignatureWrapper wrapper) |
| throws CoreException { |
| char[] genericSignature = wrapper.signature; |
| if (genericSignature.length == 0 || wrapper.charAtStart() != '<') { |
| return; |
| } |
| |
| int indexOfClosingBracket = wrapper.skipAngleContents(wrapper.start) - 1; |
| wrapper.start++; |
| NdTypeParameter parameter = null; |
| while (wrapper.start < indexOfClosingBracket) { |
| int colonPos = CharOperation.indexOf(':', genericSignature, wrapper.start, indexOfClosingBracket); |
| |
| if (colonPos > wrapper.start) { |
| char[] identifier = CharOperation.subarray(genericSignature, wrapper.start, colonPos); |
| parameter = new NdTypeParameter(type, identifier); |
| wrapper.start = colonPos + 1; |
| // The first bound is a class as long as it doesn't start with a double-colon |
| parameter.setFirstBoundIsClass(wrapper.charAtStart() != ':'); |
| } |
| |
| skipChar(wrapper, ':'); |
| |
| NdTypeSignature boundSignature = createTypeSignature(wrapper, JAVA_LANG_OBJECT_FIELD_DESCRIPTOR); |
| |
| new NdTypeBound(parameter, boundSignature); |
| } |
| |
| skipChar(wrapper, '>'); |
| } |
| |
| private char[] readNextFieldDescriptor(SignatureWrapper genericSignature) { |
| int endPosition = findEndOfFieldDescriptor(genericSignature); |
| |
| char[] result = CharArrayUtils.subarray(genericSignature.signature, genericSignature.start, endPosition); |
| genericSignature.start = endPosition; |
| return result; |
| } |
| |
| private int findEndOfFieldDescriptor(SignatureWrapper genericSignature) { |
| char[] signature = genericSignature.signature; |
| |
| if (signature == null || signature.length == 0) { |
| return genericSignature.start; |
| } |
| int current = genericSignature.start; |
| while (current < signature.length) { |
| char firstChar = signature[current]; |
| switch (firstChar) { |
| case 'L': |
| case 'T': { |
| return CharArrayUtils.indexOf(';', signature, current, signature.length) + 1; |
| } |
| case '[': { |
| current++; |
| break; |
| } |
| case 'V': |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'F': |
| case 'I': |
| case 'J': |
| case 'S': |
| case 'Z': |
| return current + 1; |
| default: |
| throw new IndexException(Package.createStatus("Field descriptor starts with unknown character: " //$NON-NLS-1$ |
| + genericSignature.toString())); |
| } |
| } |
| return current; |
| } |
| |
| /** |
| * Given a generic signature which is positioned at the open brace for method arguments, this returns the number of |
| * method arguments. The start position of the given signature is not modified. |
| */ |
| private int countMethodArguments(SignatureWrapper genericSignature) { |
| SignatureWrapper lookaheadSignature = new SignatureWrapper(genericSignature.signature); |
| lookaheadSignature.start = genericSignature.start; |
| skipChar(lookaheadSignature, '('); |
| int argumentCount = 0; |
| while (!lookaheadSignature.atEnd() && !(lookaheadSignature.charAtStart() == ')')) { |
| switch (lookaheadSignature.charAtStart()) { |
| case 'T': { |
| // Skip the 'T' prefix |
| lookaheadSignature.nextWord(); |
| skipChar(lookaheadSignature, ';'); |
| argumentCount++; |
| break; |
| } |
| case '[': { |
| // Skip the '[' prefix |
| lookaheadSignature.start++; |
| break; |
| } |
| case 'V': |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'F': |
| case 'I': |
| case 'J': |
| case 'S': |
| case 'Z': |
| argumentCount++; |
| lookaheadSignature.start++; |
| break; |
| case 'L': |
| for (;;) { |
| lookaheadSignature.nextWord(); |
| lookaheadSignature.start = lookaheadSignature.skipAngleContents(lookaheadSignature.start); |
| char nextChar = lookaheadSignature.charAtStart(); |
| if (nextChar == ';') { |
| break; |
| } |
| if (nextChar != '.') { |
| throw new IllegalStateException( |
| "Unknown char in generic signature " + lookaheadSignature.toString()); //$NON-NLS-1$ |
| } |
| } |
| skipChar(lookaheadSignature, ';'); |
| argumentCount++; |
| break; |
| default: |
| throw new IllegalStateException("Generic signature starts with unknown character: " //$NON-NLS-1$ |
| + lookaheadSignature.toString()); |
| } |
| } |
| return argumentCount; |
| } |
| |
| /** |
| * Reads a type signature from the given {@link SignatureWrapper}, starting at the character pointed to by |
| * wrapper.start. On return, wrapper.start will point to the first character following the type signature. Returns |
| * null if given an empty signature or the signature for the void type. |
| * |
| * @param genericSignature |
| * the generic signature to parse |
| * @param fieldDescriptorIfVariable |
| * the field descriptor to use if the type is a type variable -- or null if unknown (the field descriptor |
| * for java.lang.Object will be used) |
| * @throws CoreException |
| */ |
| private NdTypeSignature createTypeSignature(SignatureWrapper genericSignature, char[] fieldDescriptorIfVariable) |
| throws CoreException { |
| char[] signature = genericSignature.signature; |
| |
| if (signature == null || signature.length == 0) { |
| return null; |
| } |
| |
| char firstChar = genericSignature.charAtStart(); |
| switch (firstChar) { |
| case 'T': { |
| // Skip the 'T' prefix |
| genericSignature.start++; |
| NdComplexTypeSignature typeSignature = new NdComplexTypeSignature(getNd()); |
| char[] fieldDescriptor = fieldDescriptorIfVariable; |
| if (fieldDescriptor == null) { |
| fieldDescriptor = JAVA_LANG_OBJECT_FIELD_DESCRIPTOR; |
| } |
| typeSignature.setRawType(createTypeIdFromFieldDescriptor(fieldDescriptor)); |
| typeSignature.setVariableIdentifier(genericSignature.nextWord()); |
| // Skip the trailing semicolon |
| skipChar(genericSignature, ';'); |
| return typeSignature; |
| } |
| case '[': { |
| // Skip the '[' prefix |
| genericSignature.start++; |
| char[] nestedFieldDescriptor = null; |
| if (fieldDescriptorIfVariable != null && fieldDescriptorIfVariable.length > 0 |
| && fieldDescriptorIfVariable[0] == '[') { |
| nestedFieldDescriptor = CharArrayUtils.subarray(fieldDescriptorIfVariable, 1); |
| } |
| // Determine the array argument type |
| NdTypeSignature elementType = createTypeSignature(genericSignature, nestedFieldDescriptor); |
| char[] computedFieldDescriptor = CharArrayUtils.concat(ARRAY_FIELD_DESCRIPTOR_PREFIX, |
| elementType.getRawType().getFieldDescriptor().getChars()); |
| NdTypeId rawType = createTypeIdFromFieldDescriptor(computedFieldDescriptor); |
| // We encode signatures as though they were a one-argument generic type whose element |
| // type is the generic argument. |
| NdComplexTypeSignature typeSignature = new NdComplexTypeSignature(getNd()); |
| typeSignature.setRawType(rawType); |
| NdTypeArgument typeArgument = new NdTypeArgument(getNd(), typeSignature); |
| typeArgument.setType(elementType); |
| return typeSignature; |
| } |
| case 'V': |
| genericSignature.start++; |
| return null; |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'F': |
| case 'I': |
| case 'J': |
| case 'S': |
| case 'Z': |
| genericSignature.start++; |
| return createTypeIdFromFieldDescriptor(new char[] { firstChar }); |
| case 'L': |
| return parseClassTypeSignature(null, genericSignature); |
| case '+': |
| case '-': |
| case '*': |
| throw new CoreException(Package.createStatus("Unexpected wildcard in top-level of generic signature: " //$NON-NLS-1$ |
| + genericSignature.toString())); |
| default: |
| throw new CoreException(Package.createStatus("Generic signature starts with unknown character: " //$NON-NLS-1$ |
| + genericSignature.toString())); |
| } |
| } |
| |
| /** |
| * Parses a ClassTypeSignature (as described in section 4.7.9.1 of the Java VM Specification Java SE 8 Edition). The |
| * read pointer should be located just after the identifier. The caller is expected to have already read the field |
| * descriptor for the type. |
| */ |
| private NdTypeSignature parseClassTypeSignature(NdComplexTypeSignature parentTypeOrNull, SignatureWrapper wrapper) |
| throws CoreException { |
| char[] identifier = wrapper.nextWord(); |
| char[] fieldDescriptor; |
| |
| if (parentTypeOrNull != null) { |
| fieldDescriptor = CharArrayUtils.concat( |
| parentTypeOrNull.getRawType().getFieldDescriptorWithoutTrailingSemicolon(), |
| INNER_TYPE_SEPARATOR, identifier, FIELD_DESCRIPTOR_SUFFIX); |
| } else { |
| fieldDescriptor = CharArrayUtils.concat(identifier, FIELD_DESCRIPTOR_SUFFIX); |
| } |
| |
| char[] genericSignature = wrapper.signature; |
| boolean hasGenericArguments = (genericSignature.length > wrapper.start) |
| && genericSignature[wrapper.start] == '<'; |
| boolean isRawTypeWithNestedClass = genericSignature[wrapper.start] == '.'; |
| NdTypeId rawType = createTypeIdFromFieldDescriptor(fieldDescriptor); |
| NdTypeSignature result = rawType; |
| |
| boolean checkForSemicolon = true; |
| // Special optimization for signatures with no type annotations, no arrays, and no generic arguments that |
| // are not an inner type of a class that can't use this optimization. Basically, if there would be no attributes |
| // set on a NdComplexTypeSignature besides what it picks up from its raw type, we just use the raw type. |
| if (hasGenericArguments || parentTypeOrNull != null || isRawTypeWithNestedClass) { |
| NdComplexTypeSignature typeSignature = new NdComplexTypeSignature(getNd()); |
| typeSignature.setRawType(rawType); |
| |
| if (hasGenericArguments) { |
| wrapper.start++; |
| while (wrapper.start < genericSignature.length && (genericSignature[wrapper.start] != '>')) { |
| NdTypeArgument typeArgument = new NdTypeArgument(getNd(), typeSignature); |
| |
| switch (genericSignature[wrapper.start]) { |
| case '+': { |
| typeArgument.setWildcard(NdTypeArgument.WILDCARD_SUPER); |
| wrapper.start++; |
| break; |
| } |
| case '-': { |
| typeArgument.setWildcard(NdTypeArgument.WILDCARD_EXTENDS); |
| wrapper.start++; |
| break; |
| } |
| case '*': { |
| typeArgument.setWildcard(NdTypeArgument.WILDCARD_QUESTION); |
| wrapper.start++; |
| continue; |
| } |
| } |
| |
| NdTypeSignature nextSignature = createTypeSignature(wrapper, null); |
| typeArgument.setType(nextSignature); |
| } |
| |
| skipChar(wrapper, '>'); |
| } |
| result = typeSignature; |
| |
| if (parentTypeOrNull != null) { |
| typeSignature.setGenericDeclaringType(parentTypeOrNull); |
| } |
| |
| if (genericSignature[wrapper.start] == '.') { |
| // Don't check for a semicolon if we hit this branch since the recursive call to parseClassTypeSignature |
| // will do this |
| checkForSemicolon = false; |
| // Identifiers shouldn't start with '.' |
| skipChar(wrapper, '.'); |
| result = parseClassTypeSignature(typeSignature, wrapper); |
| } |
| } |
| |
| if (checkForSemicolon) { |
| skipChar(wrapper, ';'); |
| } |
| |
| return result; |
| } |
| |
| private NdTypeId createTypeIdFromFieldDescriptor(char[] typeName) { |
| if (typeName == null) { |
| return null; |
| } |
| return this.index.createTypeId(typeName); |
| } |
| |
| /** |
| * Creates a method ID given a method selector, method descriptor, and binary type name |
| */ |
| private NdMethodId createMethodId(char[] binaryTypeName, char[] methodSelector, char[] methodDescriptor) { |
| if (methodSelector == null || binaryTypeName == null || methodDescriptor == null) { |
| return null; |
| } |
| |
| char[] methodId = JavaNames.getMethodId(binaryTypeName, methodSelector, methodDescriptor); |
| return this.index.createMethodId(methodId); |
| } |
| |
| /** |
| * Creates a method ID given a method name (which is a method selector followed by a method descriptor. |
| */ |
| private NdMethodId createMethodId(char[] binaryTypeName, char[] methodName) { |
| if (methodName == null || binaryTypeName == null) { |
| return null; |
| } |
| |
| char[] methodId = JavaNames.getMethodId(binaryTypeName, methodName); |
| return this.index.createMethodId(methodId); |
| } |
| |
| private void initTypeAnnotation(NdTypeAnnotation annotation, IBinaryTypeAnnotation next) { |
| int[] typePath = next.getTypePath(); |
| if (typePath != null && typePath.length > 0) { |
| byte[] bytePath = new byte[typePath.length]; |
| for (int idx = 0; idx < bytePath.length; idx++) { |
| bytePath[idx] = (byte)typePath[idx]; |
| } |
| annotation.setPath(bytePath); |
| } |
| int targetType = next.getTargetType(); |
| annotation.setTargetType(targetType); |
| switch (targetType) { |
| case AnnotationTargetTypeConstants.METHOD_TYPE_PARAMETER: |
| case AnnotationTargetTypeConstants.CLASS_TYPE_PARAMETER: |
| annotation.setTargetInfo(next.getTypeParameterIndex()); |
| break; |
| case AnnotationTargetTypeConstants.CLASS_EXTENDS: |
| annotation.setTargetInfo(next.getSupertypeIndex()); |
| break; |
| case AnnotationTargetTypeConstants.CLASS_TYPE_PARAMETER_BOUND: |
| case AnnotationTargetTypeConstants.METHOD_TYPE_PARAMETER_BOUND: |
| annotation.setTargetInfo((byte)next.getTypeParameterIndex(), (byte)next.getBoundIndex()); |
| break; |
| case AnnotationTargetTypeConstants.FIELD: |
| case AnnotationTargetTypeConstants.METHOD_RETURN: |
| case AnnotationTargetTypeConstants.METHOD_RECEIVER: |
| break; |
| case AnnotationTargetTypeConstants.METHOD_FORMAL_PARAMETER : |
| annotation.setTargetInfo(next.getMethodFormalParameterIndex()); |
| break; |
| case AnnotationTargetTypeConstants.THROWS : |
| annotation.setTargetInfo(next.getThrowsTypeIndex()); |
| break; |
| |
| default: |
| throw new IllegalStateException("Target type not handled " + targetType); //$NON-NLS-1$ |
| } |
| initAnnotation(annotation, next.getAnnotation()); |
| } |
| |
| private void initAnnotation(NdAnnotation annotation, IBinaryAnnotation next) { |
| annotation.setType(createTypeIdFromBinaryName(next.getTypeName())); |
| |
| IBinaryElementValuePair[] pairs = next.getElementValuePairs(); |
| |
| if (pairs != null) { |
| for (IBinaryElementValuePair element : pairs) { |
| NdAnnotationValuePair nextPair = new NdAnnotationValuePair(annotation, element.getName()); |
| nextPair.setValue(createConstantFromMixedType(element.getValue())); |
| } |
| } |
| } |
| |
| private void logInfo(String string) { |
| if (ENABLE_LOGGING) { |
| Package.logInfo(string); |
| } |
| } |
| |
| private NdTypeId createTypeIdFromBinaryName(char[] binaryName) { |
| if (binaryName == null) { |
| return null; |
| } |
| |
| return this.index.createTypeId(JavaNames.binaryNameToFieldDescriptor(binaryName)); |
| } |
| |
| /** |
| * |
| * @param value |
| * accepts all values returned from {@link IBinaryElementValuePair#getValue()} |
| */ |
| public NdConstant createConstantFromMixedType(Object value) { |
| if (value instanceof Constant) { |
| Constant constant = (Constant) value; |
| |
| return NdConstant.create(getNd(), constant); |
| } else if (value instanceof ClassSignature) { |
| ClassSignature signature = (ClassSignature) value; |
| |
| char[] binaryName = JavaNames.binaryNameToFieldDescriptor(signature.getTypeName()); |
| NdTypeSignature typeId = this.index.createTypeId(binaryName); |
| return NdConstantClass.create(getNd(), typeId); |
| } else if (value instanceof IBinaryAnnotation) { |
| IBinaryAnnotation binaryAnnotation = (IBinaryAnnotation) value; |
| |
| NdAnnotationInConstant annotation = new NdAnnotationInConstant(getNd()); |
| initAnnotation(annotation, binaryAnnotation); |
| return NdConstantAnnotation.create(getNd(), annotation); |
| } else if (value instanceof Object[]) { |
| NdConstantArray result = new NdConstantArray(getNd()); |
| Object[] array = (Object[]) value; |
| |
| for (Object next : array) { |
| NdConstant nextConstant = createConstantFromMixedType(next); |
| nextConstant.setParent(result); |
| } |
| return result; |
| } else if (value instanceof EnumConstantSignature) { |
| EnumConstantSignature signature = (EnumConstantSignature) value; |
| |
| NdConstantEnum result = NdConstantEnum.create(createTypeIdFromBinaryName(signature.getTypeName()), |
| new String(signature.getEnumConstantName())); |
| |
| return result; |
| } |
| throw new IllegalStateException("Unknown constant type " + value.getClass().getName()); //$NON-NLS-1$ |
| } |
| } |
